@floegence/flowersec-core 0.17.2 → 0.19.0

package/dist/connect/internalNormalize.d.ts

@@ -0,0 +1,22 @@
+import { type ClientObserverLike } from "../observability/observer.js";
+import { type CorrelationContext, type ScopeMetadataEntry } from "./artifact.js";
+export type ConnectScopeResolver = (entry: ScopeMetadataEntry) => void | Promise<void>;
+export type ConnectScopeResolverMap = Readonly<Record<string, ConnectScopeResolver>>;
+type NormalizeOptions = Readonly<{
+    observer?: ClientObserverLike;
+    scopeResolvers?: ConnectScopeResolverMap;
+    relaxedOptionalScopeValidation?: boolean;
+}>;
+export type NormalizedConnectInput = Readonly<{
+    kind: "tunnel";
+    input: unknown;
+    correlation?: CorrelationContext;
+    observer?: ClientObserverLike;
+}> | Readonly<{
+    kind: "direct";
+    input: unknown;
+    correlation?: CorrelationContext;
+    observer?: ClientObserverLike;
+}>;
+export declare function normalizeConnectInput(input: unknown, opts?: NormalizeOptions): Promise<NormalizedConnectInput>;
+export {};

package/dist/connect/internalNormalize.js

@@ -0,0 +1,173 @@
+import { Role as ControlRole } from "../gen/flowersec/controlplane/v1.gen.js";
+import { emitObserverDiagnostic, normalizeObserver, withObserverContext } from "../observability/observer.js";
+import { FlowersecError } from "../utils/errors.js";
+import { assertConnectArtifact, hasArtifactOnlyFields, } from "./artifact.js";
+function maybeParseJSON(input) {
+    if (typeof input !== "string")
+        return input;
+    const s = input.trim();
+    if (s === "")
+        return input;
+    if (s[0] !== "{" && s[0] !== "[")
+        return input;
+    try {
+        return JSON.parse(s);
+    }
+    catch (e) {
+        throw new FlowersecError({
+            path: "auto",
+            stage: "validate",
+            code: "invalid_input",
+            message: "invalid JSON string",
+            cause: e,
+        });
+    }
+}
+async function validateArtifactScopes(artifact, opts, observer) {
+    const scoped = artifact.scoped ?? [];
+    if (scoped.length === 0)
+        return;
+    const path = artifact.transport;
+    for (const entry of scoped) {
+        const resolver = opts.scopeResolvers?.[entry.scope];
+        if (resolver == null) {
+            if (entry.critical) {
+                throw new FlowersecError({
+                    path,
+                    stage: "validate",
+                    code: "resolve_failed",
+                    message: `missing scope resolver for ${entry.scope}@${entry.scope_version}`,
+                });
+            }
+            emitObserverDiagnostic(observer, {
+                path,
+                stage: "scope",
+                code_domain: "event",
+                code: "scope_ignored_missing_resolver",
+                result: "skip",
+            });
+            continue;
+        }
+        try {
+            await resolver(entry);
+        }
+        catch (e) {
+            if (!entry.critical && opts.relaxedOptionalScopeValidation === true) {
+                emitObserverDiagnostic(observer, {
+                    path,
+                    stage: "scope",
+                    code_domain: "event",
+                    code: "scope_ignored_relaxed_validation",
+                    result: "skip",
+                });
+                continue;
+            }
+            throw new FlowersecError({
+                path,
+                stage: "validate",
+                code: "resolve_failed",
+                message: `scope validation failed for ${entry.scope}@${entry.scope_version}`,
+                cause: e,
+            });
+        }
+    }
+}
+export async function normalizeConnectInput(input, opts = {}) {
+    const v = maybeParseJSON(input);
+    if (v == null || typeof v !== "object") {
+        throw new FlowersecError({
+            path: "auto",
+            stage: "validate",
+            code: "invalid_input",
+            message: "invalid input: expected an object or a JSON string",
+        });
+    }
+    const o = v;
+    const hasWsUrl = Object.prototype.hasOwnProperty.call(o, "ws_url");
+    const hasTunnelUrl = Object.prototype.hasOwnProperty.call(o, "tunnel_url");
+    const hasGrantClient = Object.prototype.hasOwnProperty.call(o, "grant_client");
+    const hasGrantServer = Object.prototype.hasOwnProperty.call(o, "grant_server");
+    const isArtifactCandidate = hasArtifactOnlyFields(o);
+    if ((hasWsUrl && (hasTunnelUrl || hasGrantClient || hasGrantServer)) || (hasTunnelUrl && (hasGrantClient || hasGrantServer))) {
+        throw new FlowersecError({
+            path: "auto",
+            stage: "validate",
+            code: "invalid_input",
+            message: "hybrid connect input is not allowed",
+        });
+    }
+    if (isArtifactCandidate && (hasWsUrl || hasTunnelUrl || hasGrantClient || hasGrantServer)) {
+        throw new FlowersecError({
+            path: "auto",
+            stage: "validate",
+            code: "invalid_input",
+            message: "artifact fields cannot be mixed with legacy connect inputs",
+        });
+    }
+    if (hasGrantServer) {
+        throw new FlowersecError({
+            path: "tunnel",
+            stage: "validate",
+            code: "role_mismatch",
+            message: "expected role=client",
+        });
+    }
+    if (hasGrantClient)
+        return { kind: "tunnel", input: v };
+    if (hasWsUrl)
+        return { kind: "direct", input: v };
+    if (hasTunnelUrl) {
+        if (typeof o.role === "number" && Number.isSafeInteger(o.role) && o.role === ControlRole.Role_server) {
+            throw new FlowersecError({
+                path: "tunnel",
+                stage: "validate",
+                code: "role_mismatch",
+                message: "expected role=client",
+            });
+        }
+        return { kind: "tunnel", input: v };
+    }
+    if (isArtifactCandidate) {
+        let artifact;
+        try {
+            artifact = assertConnectArtifact(v);
+        }
+        catch (e) {
+            throw new FlowersecError({
+                path: "auto",
+                stage: "validate",
+                code: "invalid_input",
+                message: "invalid ConnectArtifact",
+                cause: e,
+            });
+        }
+        const observer = opts.observer == null
+            ? undefined
+            : normalizeObserver(withObserverContext(opts.observer, {
+                path: artifact.transport,
+                ...(artifact.correlation?.trace_id === undefined ? {} : { traceId: artifact.correlation.trace_id }),
+                ...(artifact.correlation?.session_id === undefined ? {} : { sessionId: artifact.correlation.session_id }),
+            }), { path: artifact.transport });
+        await validateArtifactScopes(artifact, opts, observer);
+        if (artifact.transport === "direct") {
+            return {
+                kind: "direct",
+                input: artifact.direct_info,
+                ...(artifact.correlation === undefined ? {} : { correlation: artifact.correlation }),
+                ...(observer === undefined ? {} : { observer }),
+            };
+        }
+        return {
+            kind: "tunnel",
+            input: artifact.tunnel_grant,
+            ...(artifact.correlation === undefined ? {} : { correlation: artifact.correlation }),
+            ...(observer === undefined ? {} : { observer }),
+        };
+    }
+    throw new FlowersecError({
+        path: "auto",
+        stage: "validate",
+        code: "invalid_input",
+        message: "invalid input: expected DirectConnectInfo, ChannelInitGrant, wrapper, or ConnectArtifact",
+    });
+}

package/dist/controlplane/index.d.ts

@@ -0,0 +1,2 @@
+export type { ArtifactRequestCorrelation, ConnectArtifactEnvelope, ControlplaneBaseConfig, ControlplaneErrorEnvelope, RequestConnectArtifactInput, RequestEntryConnectArtifactInput, } from "./request.js";
+export { ControlplaneRequestError, DEFAULT_CONNECT_ARTIFACT_PATH, DEFAULT_ENTRY_CONNECT_ARTIFACT_PATH, requestConnectArtifact, requestEntryConnectArtifact, } from "./request.js";

package/dist/controlplane/index.js

@@ -0,0 +1 @@
+export { ControlplaneRequestError, DEFAULT_CONNECT_ARTIFACT_PATH, DEFAULT_ENTRY_CONNECT_ARTIFACT_PATH, requestConnectArtifact, requestEntryConnectArtifact, } from "./request.js";

package/dist/controlplane/request.d.ts

@@ -0,0 +1,50 @@
+import { type ConnectArtifact } from "../connect/artifact.js";
+type FetchLike = typeof fetch;
+export type ControlplaneBaseConfig = Readonly<{
+    baseUrl?: string;
+    path?: string;
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    fetch?: FetchLike;
+    signal?: AbortSignal;
+}>;
+export type ArtifactRequestCorrelation = Readonly<{
+    traceId?: string;
+}>;
+export type RequestConnectArtifactInput = ControlplaneBaseConfig & Readonly<{
+    endpointId: string;
+    payload?: Record<string, unknown>;
+    correlation?: ArtifactRequestCorrelation;
+}>;
+export type RequestEntryConnectArtifactInput = RequestConnectArtifactInput & Readonly<{
+    entryTicket: string;
+}>;
+export type ConnectArtifactEnvelope = Readonly<{
+    connect_artifact: ConnectArtifact;
+}>;
+export type ControlplaneErrorEnvelope = Readonly<{
+    error: Readonly<{
+        code: string;
+        message: string;
+    }>;
+}>;
+export declare class ControlplaneRequestError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly responseBody: unknown;
+    constructor(args: Readonly<{
+        status: number;
+        message: string;
+        code?: string;
+        responseBody?: unknown;
+    }>);
+}
+export declare const DEFAULT_CONNECT_ARTIFACT_PATH = "/v1/connect/artifact";
+export declare const DEFAULT_ENTRY_CONNECT_ARTIFACT_PATH = "/v1/connect/artifact/entry";
+export declare function buildControlplaneURL(baseUrl: string | undefined, path: string): string;
+export declare function requestControlplaneJSON(url: string, init: RequestInit & Readonly<{
+    fetch?: FetchLike;
+}>): Promise<unknown>;
+export declare function requestConnectArtifact(config: RequestConnectArtifactInput): Promise<ConnectArtifact>;
+export declare function requestEntryConnectArtifact(config: RequestEntryConnectArtifactInput): Promise<ConnectArtifact>;
+export {};

package/dist/controlplane/request.js

@@ -0,0 +1,136 @@
+import { assertConnectArtifact } from "../connect/artifact.js";
+export class ControlplaneRequestError extends Error {
+    status;
+    code;
+    responseBody;
+    constructor(args) {
+        super(args.message);
+        this.name = "ControlplaneRequestError";
+        this.status = args.status;
+        this.code = String(args.code ?? "").trim();
+        this.responseBody = args.responseBody;
+    }
+}
+export const DEFAULT_CONNECT_ARTIFACT_PATH = "/v1/connect/artifact";
+export const DEFAULT_ENTRY_CONNECT_ARTIFACT_PATH = "/v1/connect/artifact/entry";
+function resolveFetch(fetchImpl) {
+    if (fetchImpl)
+        return fetchImpl;
+    if (typeof globalThis.fetch === "function")
+        return globalThis.fetch.bind(globalThis);
+    throw new Error("global fetch is not available");
+}
+export function buildControlplaneURL(baseUrl, path) {
+    const base = String(baseUrl ?? "").trim();
+    if (base === "")
+        return path;
+    return `${base.replace(/\/+$/, "")}${path}`;
+}
+function parseMaybeJSON(bodyText) {
+    const trimmed = String(bodyText ?? "").trim();
+    if (trimmed === "")
+        return "";
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function decodeErrorMessage(status, responseBody) {
+    let message = `controlplane request failed: ${status}`;
+    let code = "";
+    if (responseBody && typeof responseBody === "object") {
+        const error = responseBody.error;
+        if (error && typeof error === "object") {
+            const nextMessage = String(error.message ?? "").trim();
+            if (nextMessage !== "") {
+                message = nextMessage;
+            }
+            code = String(error.code ?? "").trim();
+        }
+    }
+    else if (typeof responseBody === "string" && responseBody !== "") {
+        message = responseBody;
+    }
+    return { code, message };
+}
+export async function requestControlplaneJSON(url, init) {
+    const runFetch = resolveFetch(init.fetch);
+    const response = await runFetch(url, {
+        ...init,
+        cache: "no-store",
+    });
+    const rawBody = await response.text();
+    const responseBody = parseMaybeJSON(rawBody);
+    if (!response.ok) {
+        const error = decodeErrorMessage(response.status, responseBody);
+        throw new ControlplaneRequestError({
+            status: response.status,
+            message: error.message,
+            code: error.code,
+            responseBody,
+        });
+    }
+    if (typeof responseBody === "string") {
+        if (responseBody === "") {
+            throw new Error("Invalid controlplane response: expected JSON body");
+        }
+        throw new Error("Invalid controlplane response: expected JSON body");
+    }
+    return responseBody;
+}
+function buildConnectArtifactPayload(config) {
+    const body = {
+        endpoint_id: String(config.endpointId ?? "").trim(),
+    };
+    if (body.endpoint_id === "")
+        throw new Error("endpointId is required");
+    if (config.payload !== undefined)
+        body.payload = { ...config.payload };
+    const traceId = String(config.correlation?.traceId ?? "").trim();
+    if (traceId !== "") {
+        body.correlation = { trace_id: traceId };
+    }
+    return body;
+}
+function createJSONHeaders(input) {
+    const headers = new Headers(input);
+    if (!headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    return headers;
+}
+export async function requestConnectArtifact(config) {
+    const data = (await requestControlplaneJSON(buildControlplaneURL(config.baseUrl, config.path ?? DEFAULT_CONNECT_ARTIFACT_PATH), {
+        ...(config.fetch === undefined ? {} : { fetch: config.fetch }),
+        method: "POST",
+        credentials: config.credentials ?? "omit",
+        headers: createJSONHeaders(config.headers),
+        body: JSON.stringify(buildConnectArtifactPayload(config)),
+        ...(config.signal === undefined ? {} : { signal: config.signal }),
+    }));
+    if (!data?.connect_artifact) {
+        throw new Error("Invalid controlplane response: missing `connect_artifact`");
+    }
+    return assertConnectArtifact(data.connect_artifact);
+}
+export async function requestEntryConnectArtifact(config) {
+    const entryTicket = String(config.entryTicket ?? "").trim();
+    if (entryTicket === "")
+        throw new Error("entryTicket is required");
+    const headers = createJSONHeaders(config.headers);
+    headers.set("Authorization", `Bearer ${entryTicket}`);
+    const data = (await requestControlplaneJSON(buildControlplaneURL(config.baseUrl, config.path ?? DEFAULT_ENTRY_CONNECT_ARTIFACT_PATH), {
+        ...(config.fetch === undefined ? {} : { fetch: config.fetch }),
+        method: "POST",
+        credentials: config.credentials ?? "omit",
+        headers,
+        body: JSON.stringify(buildConnectArtifactPayload(config)),
+        ...(config.signal === undefined ? {} : { signal: config.signal }),
+    }));
+    if (!data?.connect_artifact) {
+        throw new Error("Invalid controlplane response: missing `connect_artifact`");
+    }
+    return assertConnectArtifact(data.connect_artifact);
+}

package/dist/e2ee/secureChannel.js

@@ -68,8 +68,6 @@ export class SecureChannel {
     // read resolves with the next plaintext chunk or throws on errors/close.
     async read() {
         while (true) {
-            if (this.readErr != null)
-                throw this.readErr;
             if (this.recvQueueHead < this.recvQueue.length) {
                 const b = this.recvQueue[this.recvQueueHead];
                 this.recvQueueHead++;
@@ -80,6 +78,8 @@ export class SecureChannel {
                 this.recvQueueBytes -= b.length;
                 return b;
             }
+            if (this.readErr != null)
+                throw this.readErr;
             if (this.closed)
                 throw new Error("closed");
             await new Promise((resolve) => this.recvWaiters.push(resolve));
@@ -94,9 +94,6 @@ export class SecureChannel {
         this.rejectQueuedSenders(this.sendErr ?? new Error("closed"));
         this.wakeSendWaiters();
         this.transport.close();
-        this.recvQueue.length = 0;
-        this.recvQueueHead = 0;
-        this.recvQueueBytes = 0;
         const ws = this.recvWaiters;
         this.recvWaiters = [];
         for (const w of ws)

package/dist/facade.d.ts

@@ -1,12 +1,15 @@
 import type { Client } from "./client.js";
 import type { DirectConnectOptions } from "./direct-client/connect.js";
 import type { TunnelConnectOptions } from "./tunnel-client/connect.js";
+import { type ConnectArtifact, type CorrelationContext, type CorrelationKV, type DirectClientConnectArtifact, type ScopeMetadataEntry, type TunnelClientConnectArtifact } from "./connect/artifact.js";
 import type { ChannelInitGrant } from "./gen/flowersec/controlplane/v1.gen.js";
 import type { DirectConnectInfo } from "./gen/flowersec/direct/v1.gen.js";
 export type { ChannelInitGrant } from "./gen/flowersec/controlplane/v1.gen.js";
 export { assertChannelInitGrant } from "./gen/flowersec/controlplane/v1.gen.js";
 export type { DirectConnectInfo } from "./gen/flowersec/direct/v1.gen.js";
 export { assertDirectConnectInfo } from "./gen/flowersec/direct/v1.gen.js";
+export type { ConnectArtifact, CorrelationContext, CorrelationKV, DirectClientConnectArtifact, ScopeMetadataEntry, TunnelClientConnectArtifact, };
+export { assertConnectArtifact } from "./connect/artifact.js";
 export type { ClientObserverLike } from "./observability/observer.js";
 export type { Client, ClientPath } from "./client.js";
 export type { FlowersecErrorCode, FlowersecPath, FlowersecStage } from "./utils/errors.js";
@@ -18,4 +21,5 @@ export declare function connectTunnel(grant: ChannelInitGrant, opts: TunnelConne
 export declare function connectDirect(info: DirectConnectInfo, opts: DirectConnectOptions): Promise<Client>;
 export declare function connect(input: DirectConnectInfo, opts: DirectConnectOptions): Promise<Client>;
 export declare function connect(input: ChannelInitGrant, opts: TunnelConnectOptions): Promise<Client>;
+export declare function connect(input: ConnectArtifact, opts: ConnectOptions): Promise<Client>;
 export declare function connect(input: unknown, opts: ConnectOptions): Promise<Client>;

package/dist/facade.js

@@ -1,8 +1,10 @@
 import { connectDirect as connectDirectInternal } from "./direct-client/connect.js";
 import { connectTunnel as connectTunnelInternal } from "./tunnel-client/connect.js";
-import { FlowersecError } from "./utils/errors.js";
+import { normalizeConnectInput } from "./connect/internalNormalize.js";
+import { withObserverContext } from "./observability/observer.js";
 export { assertChannelInitGrant } from "./gen/flowersec/controlplane/v1.gen.js";
 export { assertDirectConnectInfo } from "./gen/flowersec/direct/v1.gen.js";
+export { assertConnectArtifact } from "./connect/artifact.js";
 export { FlowersecError } from "./utils/errors.js";
 export async function connectTunnel(grant, opts) {
     return await connectTunnelInternal(grant, opts);
@@ -10,52 +12,18 @@ export async function connectTunnel(grant, opts) {
 export async function connectDirect(info, opts) {
     return await connectDirectInternal(info, opts);
 }
-function maybeParseJSON(input) {
-    if (typeof input !== "string")
-        return input;
-    const s = input.trim();
-    if (s === "")
-        return input;
-    if (s[0] !== "{" && s[0] !== "[")
-        return input;
-    try {
-        return JSON.parse(s);
-    }
-    catch (e) {
-        throw new FlowersecError({
-            path: "auto",
-            stage: "validate",
-            code: "invalid_input",
-            message: "invalid JSON string",
-            cause: e,
-        });
-    }
-}
 export async function connect(input, opts) {
-    const v = maybeParseJSON(input);
-    if (v != null && typeof v === "object") {
-        const o = v;
-        if (o["ws_url"] !== undefined)
-            return await connectDirectInternal(v, opts);
-        if (o["grant_client"] !== undefined)
-            return await connectTunnelInternal(v, opts);
-        if (o["grant_server"] !== undefined)
-            return await connectTunnelInternal(v, opts);
-        if (o["tunnel_url"] !== undefined)
-            return await connectTunnelInternal(v, opts);
-        if (o["token"] !== undefined || o["role"] !== undefined)
-            return await connectTunnelInternal(v, opts);
-        throw new FlowersecError({
-            path: "auto",
-            stage: "validate",
-            code: "invalid_input",
-            message: "invalid input: expected DirectConnectInfo (ws_url) or ChannelInitGrant (tunnel_url, grant_client, or grant_server)",
-        });
+    const normalized = await normalizeConnectInput(input, opts);
+    const nextObserver = normalized.observer ??
+        (normalized.correlation == null
+            ? opts.observer
+            : withObserverContext(opts.observer, {
+                ...(normalized.correlation.trace_id === undefined ? {} : { traceId: normalized.correlation.trace_id }),
+                ...(normalized.correlation.session_id === undefined ? {} : { sessionId: normalized.correlation.session_id }),
+            }));
+    const nextOpts = (nextObserver === opts.observer ? opts : { ...opts, observer: nextObserver });
+    if (normalized.kind === "direct") {
+        return await connectDirectInternal(normalized.input, nextOpts);
     }
-    throw new FlowersecError({
-        path: "auto",
-        stage: "validate",
-        code: "invalid_input",
-        message: "invalid input: expected an object or a JSON string",
-    });
+    return await connectTunnelInternal(normalized.input, nextOpts);
 }

package/dist/node/connect.d.ts

@@ -1,9 +1,12 @@
 import type { Client } from "../client.js";
 import type { DirectConnectOptions } from "../direct-client/connect.js";
 import type { TunnelConnectOptions } from "../tunnel-client/connect.js";
+import { type ConnectOptions } from "../facade.js";
+import type { ConnectArtifact } from "../connect/artifact.js";
 import type { ChannelInitGrant } from "../gen/flowersec/controlplane/v1.gen.js";
 import type { DirectConnectInfo } from "../gen/flowersec/direct/v1.gen.js";
 export declare function connectNode(input: DirectConnectInfo, opts: DirectConnectOptions): Promise<Client>;
 export declare function connectNode(input: ChannelInitGrant, opts: TunnelConnectOptions): Promise<Client>;
+export declare function connectNode(input: ConnectArtifact, opts: ConnectOptions): Promise<Client>;
 export declare function connectTunnelNode(grant: ChannelInitGrant, opts: TunnelConnectOptions): Promise<Client>;
 export declare function connectDirectNode(info: DirectConnectInfo, opts: DirectConnectOptions): Promise<Client>;

package/dist/node/index.d.ts

@@ -1,2 +1,6 @@
 export { createNodeWsFactory } from "./wsFactory.js";
 export { connectDirectNode, connectNode, connectTunnelNode } from "./connect.js";
+export type { DirectNodeReconnectConfig, NodeReconnectConfig, TunnelNodeReconnectConfig, } from "./reconnectConfig.js";
+export { createDirectNodeReconnectConfig, createNodeReconnectConfig, createTunnelNodeReconnectConfig, } from "./reconnectConfig.js";
+export type { ConnectArtifact, CorrelationContext, CorrelationKV, DirectClientConnectArtifact, ScopeMetadataEntry, TunnelClientConnectArtifact, } from "../connect/artifact.js";
+export { assertConnectArtifact } from "../connect/artifact.js";

package/dist/node/index.js

@@ -1,2 +1,4 @@
 export { createNodeWsFactory } from "./wsFactory.js";
 export { connectDirectNode, connectNode, connectTunnelNode } from "./connect.js";
+export { createDirectNodeReconnectConfig, createNodeReconnectConfig, createTunnelNodeReconnectConfig, } from "./reconnectConfig.js";
+export { assertConnectArtifact } from "../connect/artifact.js";

package/dist/node/reconnectConfig.d.ts

@@ -0,0 +1,42 @@
+import type { ConnectArtifact } from "../connect/artifact.js";
+import type { ChannelInitGrant } from "../gen/flowersec/controlplane/v1.gen.js";
+import type { DirectConnectInfo } from "../gen/flowersec/direct/v1.gen.js";
+import type { ClientObserverLike } from "../observability/observer.js";
+import type { DirectConnectOptions } from "../direct-client/connect.js";
+import type { TunnelConnectOptions } from "../tunnel-client/connect.js";
+import type { AutoReconnectConfig, ConnectConfig as ReconnectConnectConfig } from "../reconnect/index.js";
+import { type ArtifactAwareReconnectConfig, type ArtifactFactoryArgs } from "../reconnect/artifactControlplane.js";
+import type { RequestConnectArtifactInput, RequestEntryConnectArtifactInput } from "../controlplane/index.js";
+type SharedReconnectOptions = Readonly<{
+    observer?: ClientObserverLike;
+    autoReconnect?: AutoReconnectConfig;
+}>;
+type TunnelReconnectConnectOptions = Omit<TunnelConnectOptions, "observer" | "signal">;
+type DirectReconnectConnectOptions = Omit<DirectConnectOptions, "observer" | "signal">;
+type ArtifactAwareTunnelReconnectConfig = ArtifactAwareReconnectConfig & Readonly<{
+    artifact?: ConnectArtifact;
+    getArtifact?: (args: ArtifactFactoryArgs) => Promise<ConnectArtifact>;
+    artifactControlplane?: RequestConnectArtifactInput | RequestEntryConnectArtifactInput;
+}>;
+type ArtifactAwareDirectReconnectConfig = ArtifactAwareReconnectConfig & Readonly<{
+    artifact?: ConnectArtifact;
+    getArtifact?: (args: ArtifactFactoryArgs) => Promise<ConnectArtifact>;
+    artifactControlplane?: RequestConnectArtifactInput | RequestEntryConnectArtifactInput;
+}>;
+export type TunnelNodeReconnectConfig = SharedReconnectOptions & ArtifactAwareTunnelReconnectConfig & Readonly<{
+    mode?: "tunnel";
+    connect?: TunnelReconnectConnectOptions;
+    grant?: ChannelInitGrant;
+    getGrant?: () => Promise<ChannelInitGrant>;
+}>;
+export type DirectNodeReconnectConfig = SharedReconnectOptions & ArtifactAwareDirectReconnectConfig & Readonly<{
+    mode: "direct";
+    connect?: DirectReconnectConnectOptions;
+    directInfo?: DirectConnectInfo;
+    getDirectInfo?: () => Promise<DirectConnectInfo>;
+}>;
+export type NodeReconnectConfig = TunnelNodeReconnectConfig | DirectNodeReconnectConfig;
+export declare function createTunnelNodeReconnectConfig(config: TunnelNodeReconnectConfig): ReconnectConnectConfig;
+export declare function createDirectNodeReconnectConfig(config: DirectNodeReconnectConfig): ReconnectConnectConfig;
+export declare function createNodeReconnectConfig(config: NodeReconnectConfig): ReconnectConnectConfig;
+export {};

package/dist/node/reconnectConfig.js

@@ -0,0 +1,78 @@
+import { resolveConnectArtifact, updateTraceId, } from "../reconnect/artifactControlplane.js";
+import { connectDirectNode, connectNode, connectTunnelNode } from "./connect.js";
+async function resolveTunnelGrant(config) {
+    if (config.getGrant)
+        return await config.getGrant();
+    if (config.grant)
+        return config.grant;
+    throw new Error("Tunnel reconnect config requires `getGrant` or `grant`");
+}
+async function resolveDirectInfo(config) {
+    if (config.getDirectInfo)
+        return await config.getDirectInfo();
+    if (config.directInfo)
+        return config.directInfo;
+    throw new Error("Direct reconnect config requires `getDirectInfo` or `directInfo`");
+}
+export function createTunnelNodeReconnectConfig(config) {
+    let traceId = config.artifact?.correlation?.trace_id;
+    return {
+        ...(config.observer === undefined ? {} : { observer: config.observer }),
+        ...(config.autoReconnect === undefined ? {} : { autoReconnect: config.autoReconnect }),
+        connectOnce: async ({ signal, observer }) => {
+            if (config.getArtifact || config.artifact || config.artifactControlplane) {
+                const artifact = await resolveConnectArtifact(config, traceId, signal);
+                if (artifact.transport !== "tunnel") {
+                    throw new Error("Tunnel reconnect config requires a tunnel ConnectArtifact");
+                }
+                traceId = updateTraceId(traceId, artifact);
+                const connectOptions = {
+                    ...(config.connect === undefined ? {} : config.connect),
+                    signal,
+                    observer,
+                };
+                return await connectNode(artifact, connectOptions);
+            }
+            const connectOptions = {
+                ...(config.connect === undefined ? {} : config.connect),
+                signal,
+                observer,
+            };
+            return await connectTunnelNode(await resolveTunnelGrant(config), connectOptions);
+        },
+    };
+}
+export function createDirectNodeReconnectConfig(config) {
+    let traceId = config.artifact?.correlation?.trace_id;
+    return {
+        ...(config.observer === undefined ? {} : { observer: config.observer }),
+        ...(config.autoReconnect === undefined ? {} : { autoReconnect: config.autoReconnect }),
+        connectOnce: async ({ signal, observer }) => {
+            if (config.getArtifact || config.artifact || config.artifactControlplane) {
+                const artifact = await resolveConnectArtifact(config, traceId, signal);
+                if (artifact.transport !== "direct") {
+                    throw new Error("Direct reconnect config requires a direct ConnectArtifact");
+                }
+                traceId = updateTraceId(traceId, artifact);
+                const connectOptions = {
+                    ...(config.connect === undefined ? {} : config.connect),
+                    signal,
+                    observer,
+                };
+                return await connectNode(artifact, connectOptions);
+            }
+            const connectOptions = {
+                ...(config.connect === undefined ? {} : config.connect),
+                signal,
+                observer,
+            };
+            return await connectDirectNode(await resolveDirectInfo(config), connectOptions);
+        },
+    };
+}
+export function createNodeReconnectConfig(config) {
+    if (config.mode === "direct") {
+        return createDirectNodeReconnectConfig(config);
+    }
+    return createTunnelNodeReconnectConfig(config);
+}