@xfcfam/xf-client 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Israel Sanjurjo and the XF contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `@xfcfam/xf-client` — transport-agnostic **outbound client contract**
+ * for the XF Architecture Model (CFAM). The Access-layer counterpart of
+ * `@xfcfam/xf-server`.
+ *
+ * Holds no transport of its own. It defines the abstract contract every
+ * concrete `@xfcfam/xf-client-*` package implements, so they all share
+ * one lifecycle and one request pipeline regardless of protocol:
+ *
+ * - **{@link ClientRepository}** — Access-Layer Generalization. Owns the
+ *   `onRequest → send → onResponse` pipeline (`call`); leaves `send` and
+ *   the wire types abstract for the protocol package.
+ * - **Exceptions**: {@link ClientException} (protocol failure — the
+ *   remote answered with an error) and {@link ConnectionException}
+ *   (transport failure — no response at all).
+ *
+ * Concrete implementations:
+ *
+ * - `@xfcfam/xf-client-http` — REST over `ky`.
+ * - `@xfcfam/xf-client-grpc` — gRPC over `@grpc/grpc-js` (sketch).
+ * - `@xfcfam/xf-client-tcp` / `-udp` — raw sockets (sketch).
+ *
+ * You typically install a concrete package, not this one directly.
+ *
+ * See https://xfcfam.org for the full XF specification.
+ */
+export { ClientRepository } from './src/repository/general/ClientRepository.js';
+export { ClientException } from './src/repository/transfers/ClientException.js';
+export { ConnectionException } from './src/repository/transfers/ConnectionException.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAA;AAG/E,OAAO,EAAE,eAAe,EAAE,MAAM,+CAA+C,CAAA;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,mDAAmD,CAAA"}

package/dist/index.js

@@ -0,0 +1,32 @@
+/**
+ * `@xfcfam/xf-client` — transport-agnostic **outbound client contract**
+ * for the XF Architecture Model (CFAM). The Access-layer counterpart of
+ * `@xfcfam/xf-server`.
+ *
+ * Holds no transport of its own. It defines the abstract contract every
+ * concrete `@xfcfam/xf-client-*` package implements, so they all share
+ * one lifecycle and one request pipeline regardless of protocol:
+ *
+ * - **{@link ClientRepository}** — Access-Layer Generalization. Owns the
+ *   `onRequest → send → onResponse` pipeline (`call`); leaves `send` and
+ *   the wire types abstract for the protocol package.
+ * - **Exceptions**: {@link ClientException} (protocol failure — the
+ *   remote answered with an error) and {@link ConnectionException}
+ *   (transport failure — no response at all).
+ *
+ * Concrete implementations:
+ *
+ * - `@xfcfam/xf-client-http` — REST over `ky`.
+ * - `@xfcfam/xf-client-grpc` — gRPC over `@grpc/grpc-js` (sketch).
+ * - `@xfcfam/xf-client-tcp` / `-udp` — raw sockets (sketch).
+ *
+ * You typically install a concrete package, not this one directly.
+ *
+ * See https://xfcfam.org for the full XF specification.
+ */
+// ── Access Generalization ─────────────────────────────────
+export { ClientRepository } from './src/repository/general/ClientRepository.js';
+// ── Exceptions ────────────────────────────────────────────
+export { ClientException } from './src/repository/transfers/ClientException.js';
+export { ConnectionException } from './src/repository/transfers/ConnectionException.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,6DAA6D;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAA;AAE/E,6DAA6D;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,+CAA+C,CAAA;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,mDAAmD,CAAA"}

package/dist/src/repository/R.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Access Layer Injection — placeholder.
+ *
+ * `R` is the canonical injection of the Access Layer. `@xfcfam/xf-client`
+ * is a contract library that contributes the abstract Generalization
+ * `ClientRepository` and Transfer objects; it owns no Logical of its
+ * own, so its `R` declares no static slots. Kept structurally complete
+ * (private constructor + empty `init` / `terminate`) so the artefact
+ * passes XF validation. NOT exported — consumers import `R` from their
+ * own artefact.
+ */
+export declare class R {
+    private constructor();
+    static init(): Promise<void>;
+    static terminate(): Promise<void>;
+}
+//# sourceMappingURL=R.d.ts.map

package/dist/src/repository/R.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"R.d.ts","sourceRoot":"","sources":["../../../src/repository/R.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,CAAC;IACZ,OAAO;WACM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;WACrB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CACxC"}

package/dist/src/repository/R.js

@@ -0,0 +1,17 @@
+/**
+ * Access Layer Injection — placeholder.
+ *
+ * `R` is the canonical injection of the Access Layer. `@xfcfam/xf-client`
+ * is a contract library that contributes the abstract Generalization
+ * `ClientRepository` and Transfer objects; it owns no Logical of its
+ * own, so its `R` declares no static slots. Kept structurally complete
+ * (private constructor + empty `init` / `terminate`) so the artefact
+ * passes XF validation. NOT exported — consumers import `R` from their
+ * own artefact.
+ */
+export class R {
+    constructor() { }
+    static async init() { }
+    static async terminate() { }
+}
+//# sourceMappingURL=R.js.map

package/dist/src/repository/R.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"R.js","sourceRoot":"","sources":["../../../src/repository/R.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,CAAC;IACZ,gBAAuB,CAAC;IACxB,MAAM,CAAC,KAAK,CAAC,IAAI,KAAmB,CAAC;IACrC,MAAM,CAAC,KAAK,CAAC,SAAS,KAAmB,CAAC;CAC3C"}

package/dist/src/repository/general/ClientRepository.d.ts

@@ -0,0 +1,59 @@
+import { Repository } from '@xfcfam/xf';
+/**
+ * Access-Layer Generalization for the artefact-level **outbound client**
+ * — the transport-agnostic contract shared by every `@xfcfam/xf-client-*`
+ * package, and the symmetric counterpart of `@xfcfam/xf-server`'s
+ * `ServerBusiness`.
+ *
+ * Where `ServerBusiness` owns the *inbound* pipeline
+ * (`onRequest → handler → onResponse`, `onError` in the catch),
+ * `ClientRepository` owns the *outbound* pipeline:
+ *
+ *   `onRequest → send → onResponse`, with `onError` in the catch.
+ *
+ * What it deliberately does **not** know is the transport: dispatching
+ * one request over the wire ({@link send}) and the request/response
+ * shapes (`TReq` / `TRes`) are left abstract. Each protocol package
+ * provides them — HTTP via `ky` in `@xfcfam/xf-client-http`, gRPC via
+ * `@grpc/grpc-js`, raw sockets via `node:net` / `node:dgram` — and
+ * exposes ergonomic helpers (`get`, `post`, `unary`, …) on top of the
+ * shared {@link call}.
+ *
+ * It lives in the **Access Layer** because making outbound calls is
+ * communication with an external system, not domain logic. Concrete
+ * subclasses are declared on `R` (e.g. `R.users`); Business components
+ * call them through the layer injection.
+ *
+ * Lifecycle (`init` / `terminate`) is inherited from {@link Repository};
+ * protocol packages open/close their client there.
+ *
+ * @typeParam TReq  Protocol-specific request type (e.g. xf-client-http's `Request`).
+ * @typeParam TRes  Protocol-specific response type (e.g. xf-client-http's `HttpResponse`).
+ */
+export declare abstract class ClientRepository<TReq, TRes> extends Repository<null> {
+    constructor();
+    /** Open the transport client. No-op by default; protocol packages override. */
+    init(): Promise<void>;
+    /** Release the transport client. No-op by default; protocol packages override. */
+    terminate(): Promise<void>;
+    /**
+     * Dispatch a single request over the transport and return the
+     * response. Implemented by the protocol package; never called
+     * directly by consumers — {@link call} wraps it in the pipeline.
+     */
+    protected abstract send(request: TReq): Promise<TRes>;
+    /**
+     * Run one outbound request through the global pipeline:
+     * `onRequest → send → onResponse`, with `onError` in the catch.
+     * Returns the response, or whatever `onError` resolves to; if
+     * `onError` returns `undefined` the original error is rethrown.
+     */
+    call(request: TReq): Promise<TRes>;
+    /** Before dispatch. Return value replaces the request (auth headers, signing, …). */
+    onRequest(request: TReq): Promise<TReq>;
+    /** After a successful dispatch. Return value replaces the response. */
+    onResponse(_request: TReq, response: TRes): Promise<TRes>;
+    /** When `send` (or a hook) throws. Return a `TRes` to recover, or `undefined` to rethrow. */
+    onError(_request: TReq, _error: unknown): Promise<TRes | undefined>;
+}
+//# sourceMappingURL=ClientRepository.d.ts.map

package/dist/src/repository/general/ClientRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientRepository.d.ts","sourceRoot":"","sources":["../../../../src/repository/general/ClientRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8BAAsB,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAE,SAAQ,UAAU,CAAC,IAAI,CAAC;;IAKzE,+EAA+E;IACzE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAE3B,kFAAkF;IAC5E,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAEhC;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAErD;;;;;OAKG;IACG,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxC,qFAAqF;IAC/E,SAAS,CAAC,OAAO,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7C,uEAAuE;IACjE,UAAU,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/D,6FAA6F;IACvF,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;CAG1E"}

package/dist/src/repository/general/ClientRepository.js

@@ -0,0 +1,74 @@
+import { Repository } from '@xfcfam/xf';
+/**
+ * Access-Layer Generalization for the artefact-level **outbound client**
+ * — the transport-agnostic contract shared by every `@xfcfam/xf-client-*`
+ * package, and the symmetric counterpart of `@xfcfam/xf-server`'s
+ * `ServerBusiness`.
+ *
+ * Where `ServerBusiness` owns the *inbound* pipeline
+ * (`onRequest → handler → onResponse`, `onError` in the catch),
+ * `ClientRepository` owns the *outbound* pipeline:
+ *
+ *   `onRequest → send → onResponse`, with `onError` in the catch.
+ *
+ * What it deliberately does **not** know is the transport: dispatching
+ * one request over the wire ({@link send}) and the request/response
+ * shapes (`TReq` / `TRes`) are left abstract. Each protocol package
+ * provides them — HTTP via `ky` in `@xfcfam/xf-client-http`, gRPC via
+ * `@grpc/grpc-js`, raw sockets via `node:net` / `node:dgram` — and
+ * exposes ergonomic helpers (`get`, `post`, `unary`, …) on top of the
+ * shared {@link call}.
+ *
+ * It lives in the **Access Layer** because making outbound calls is
+ * communication with an external system, not domain logic. Concrete
+ * subclasses are declared on `R` (e.g. `R.users`); Business components
+ * call them through the layer injection.
+ *
+ * Lifecycle (`init` / `terminate`) is inherited from {@link Repository};
+ * protocol packages open/close their client there.
+ *
+ * @typeParam TReq  Protocol-specific request type (e.g. xf-client-http's `Request`).
+ * @typeParam TRes  Protocol-specific response type (e.g. xf-client-http's `HttpResponse`).
+ */
+export class ClientRepository extends Repository {
+    constructor() {
+        super(null);
+    }
+    /** Open the transport client. No-op by default; protocol packages override. */
+    async init() { }
+    /** Release the transport client. No-op by default; protocol packages override. */
+    async terminate() { }
+    /**
+     * Run one outbound request through the global pipeline:
+     * `onRequest → send → onResponse`, with `onError` in the catch.
+     * Returns the response, or whatever `onError` resolves to; if
+     * `onError` returns `undefined` the original error is rethrown.
+     */
+    async call(request) {
+        const req = await this.onRequest(request);
+        try {
+            const res = await this.send(req);
+            return await this.onResponse(req, res);
+        }
+        catch (err) {
+            const resolved = await this.onError(req, err);
+            if (resolved !== undefined)
+                return resolved;
+            throw err;
+        }
+    }
+    // ─── Overridable global hooks (mirror ServerBusiness) ──────
+    /** Before dispatch. Return value replaces the request (auth headers, signing, …). */
+    async onRequest(request) {
+        return request;
+    }
+    /** After a successful dispatch. Return value replaces the response. */
+    async onResponse(_request, response) {
+        return response;
+    }
+    /** When `send` (or a hook) throws. Return a `TRes` to recover, or `undefined` to rethrow. */
+    async onError(_request, _error) {
+        return undefined;
+    }
+}
+//# sourceMappingURL=ClientRepository.js.map

package/dist/src/repository/general/ClientRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientRepository.js","sourceRoot":"","sources":["../../../../src/repository/general/ClientRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,OAAgB,gBAA6B,SAAQ,UAAgB;IACzE;QACE,KAAK,CAAC,IAAI,CAAC,CAAA;IACb,CAAC;IAED,+EAA+E;IAC/E,KAAK,CAAC,IAAI,KAAmB,CAAC;IAE9B,kFAAkF;IAClF,KAAK,CAAC,SAAS,KAAmB,CAAC;IASnC;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,OAAa;QACtB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;QACzC,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAChC,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;QACxC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;YAC7C,IAAI,QAAQ,KAAK,SAAS;gBAAE,OAAO,QAAQ,CAAA;YAC3C,MAAM,GAAG,CAAA;QACX,CAAC;IACH,CAAC;IAED,8DAA8D;IAE9D,qFAAqF;IACrF,KAAK,CAAC,SAAS,CAAC,OAAa;QAC3B,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,uEAAuE;IACvE,KAAK,CAAC,UAAU,CAAC,QAAc,EAAE,QAAc;QAC7C,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED,6FAA6F;IAC7F,KAAK,CAAC,OAAO,CAAC,QAAc,EAAE,MAAe;QAC3C,OAAO,SAAS,CAAA;IAClB,CAAC;CACF"}

package/dist/src/repository/transfers/ClientException.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Access-layer Exception — base class for a typed error a client raises
+ * after the remote answered with a *protocol* failure (a non-success
+ * status, a gRPC error code, a framed error packet).
+ *
+ * The mirror of `@xfcfam/xf-server`'s `ServerException`: the contract
+ * fixes only that the error carries the remote's machine-readable `body`
+ * (whatever the server actually returned — possibly `undefined` for an
+ * empty error body). How the wire status maps onto the exception is the
+ * protocol package's responsibility; protocol packages subclass this —
+ * `@xfcfam/xf-client-http`'s `RestException` adds the HTTP `status`, a
+ * gRPC client would add a `code`.
+ *
+ * A pure transport failure (no response at all) is a
+ * `ConnectionException` instead, not a `ClientException`.
+ */
+export declare class ClientException extends Error {
+    /** The remote's machine-readable payload, as returned (may be `undefined`). */
+    readonly body: unknown;
+    constructor(message: string, body?: unknown);
+}
+//# sourceMappingURL=ClientException.d.ts.map

package/dist/src/repository/transfers/ClientException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientException.d.ts","sourceRoot":"","sources":["../../../../src/repository/transfers/ClientException.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;gBAEV,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO;CAK5C"}

package/dist/src/repository/transfers/ClientException.js

@@ -0,0 +1,26 @@
+/**
+ * Access-layer Exception — base class for a typed error a client raises
+ * after the remote answered with a *protocol* failure (a non-success
+ * status, a gRPC error code, a framed error packet).
+ *
+ * The mirror of `@xfcfam/xf-server`'s `ServerException`: the contract
+ * fixes only that the error carries the remote's machine-readable `body`
+ * (whatever the server actually returned — possibly `undefined` for an
+ * empty error body). How the wire status maps onto the exception is the
+ * protocol package's responsibility; protocol packages subclass this —
+ * `@xfcfam/xf-client-http`'s `RestException` adds the HTTP `status`, a
+ * gRPC client would add a `code`.
+ *
+ * A pure transport failure (no response at all) is a
+ * `ConnectionException` instead, not a `ClientException`.
+ */
+export class ClientException extends Error {
+    /** The remote's machine-readable payload, as returned (may be `undefined`). */
+    body;
+    constructor(message, body) {
+        super(message);
+        this.name = 'ClientException';
+        this.body = body;
+    }
+}
+//# sourceMappingURL=ClientException.js.map

package/dist/src/repository/transfers/ClientException.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientException.js","sourceRoot":"","sources":["../../../../src/repository/transfers/ClientException.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IACxC,+EAA+E;IACtE,IAAI,CAAS;IAEtB,YAAY,OAAe,EAAE,IAAc;QACzC,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAC7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;CACF"}

package/dist/src/repository/transfers/ConnectionException.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Access-layer Exception — a transport-level failure that prevented a
+ * response from ever being received: the remote was unreachable,
+ * timed out, or the connection dropped mid-flight.
+ *
+ * Transport-agnostic: HTTP (DNS / TLS / socket / timeout), gRPC
+ * (`UNAVAILABLE`), raw TCP/UDP (connect / send errors) all surface as
+ * a `ConnectionException`. Distinct from a *protocol* error where the
+ * remote answered with a failing status — that is the protocol
+ * package's own exception (e.g. `RestException`).
+ */
+export declare class ConnectionException extends Error {
+    /** The originating low-level error. */
+    readonly cause: unknown;
+    /** Coarse failure kind, useful for retry policies. */
+    readonly kind: 'timeout' | 'connect' | 'network';
+    /** The originating request (protocol-specific shape), when available. */
+    readonly request?: unknown;
+    constructor(cause: unknown, kind: 'timeout' | 'connect' | 'network', request?: unknown);
+}
+//# sourceMappingURL=ConnectionException.d.ts.map

package/dist/src/repository/transfers/ConnectionException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionException.d.ts","sourceRoot":"","sources":["../../../../src/repository/transfers/ConnectionException.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,uCAAuC;IACvC,SAAkB,KAAK,EAAE,OAAO,CAAA;IAChC,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;IAChD,yEAAyE;IACzE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;gBAEd,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,OAAO;CAOvF"}

package/dist/src/repository/transfers/ConnectionException.js

@@ -0,0 +1,28 @@
+/**
+ * Access-layer Exception — a transport-level failure that prevented a
+ * response from ever being received: the remote was unreachable,
+ * timed out, or the connection dropped mid-flight.
+ *
+ * Transport-agnostic: HTTP (DNS / TLS / socket / timeout), gRPC
+ * (`UNAVAILABLE`), raw TCP/UDP (connect / send errors) all surface as
+ * a `ConnectionException`. Distinct from a *protocol* error where the
+ * remote answered with a failing status — that is the protocol
+ * package's own exception (e.g. `RestException`).
+ */
+export class ConnectionException extends Error {
+    /** The originating low-level error. */
+    cause;
+    /** Coarse failure kind, useful for retry policies. */
+    kind;
+    /** The originating request (protocol-specific shape), when available. */
+    request;
+    constructor(cause, kind, request) {
+        super(`Connection ${kind}`);
+        this.name = 'ConnectionException';
+        this.cause = cause;
+        this.kind = kind;
+        if (request !== undefined)
+            this.request = request;
+    }
+}
+//# sourceMappingURL=ConnectionException.js.map

package/dist/src/repository/transfers/ConnectionException.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionException.js","sourceRoot":"","sources":["../../../../src/repository/transfers/ConnectionException.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAC5C,uCAAuC;IACrB,KAAK,CAAS;IAChC,sDAAsD;IAC7C,IAAI,CAAmC;IAChD,yEAAyE;IAChE,OAAO,CAAU;IAE1B,YAAY,KAAc,EAAE,IAAuC,EAAE,OAAiB;QACpF,KAAK,CAAC,cAAc,IAAI,EAAE,CAAC,CAAA;QAC3B,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAA;QACjC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACnD,CAAC;CACF"}

package/package.json

@@ -1,19 +1,48 @@
 {
   "name": "@xfcfam/xf-client",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Transport-agnostic outbound client contract for the XF Architecture Model — the Access-layer counterpart of @xfcfam/xf-server.",
   "author": "XF Contributors",
   "license": "MIT",
   "homepage": "https://xfcfam.org",
-  "repository": { "type": "git", "url": "https://github.com/xfcfam/lib-npm", "directory": "packages/xf-client" },
-  "keywords": ["xf", "cfam", "client", "access"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xfcfam/lib-npm",
+    "directory": "packages/xf-client"
+  },
+  "keywords": [
+    "xf",
+    "cfam",
+    "client",
+    "access"
+  ],
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "exports": { ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" } },
-  "files": ["dist"],
-  "publishConfig": { "access": "public" },
-  "scripts": { "build": "tsc", "typecheck": "tsc --noEmit", "clean": "rm -rf dist", "test": "vitest run", "test:watch": "vitest" },
-  "peerDependencies": { "@xfcfam/xf": "workspace:^" },
-  "devDependencies": { "typescript": "^6.0.3", "vitest": "^4.1.8" }
-}
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@xfcfam/xf": "^0.3.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}