@floegence/flowersec-core 3.2.1 → 5.0.0

package/dist/transport/webTransportAdapter.d.ts

@@ -1,27 +0,0 @@
-import { type NativeCarrierSessionV2 } from "../v2/carrier.js";
-import type { PathKind } from "../v2/contract.js";
-export type WebTransportBidirectionalLikeV2 = Readonly<{
-    readable: ReadableStream<Uint8Array>;
-    writable: WritableStream<Uint8Array>;
-}>;
-export type WebTransportDatagramsLikeV2 = Readonly<{
-    readable: ReadableStream<Uint8Array>;
-    writable: WritableStream<Uint8Array>;
-    maxDatagramSize?: number;
-}>;
-export type WebTransportSessionLikeV2 = Readonly<{
-    closed: Promise<unknown>;
-    incomingBidirectionalStreams: ReadableStream<WebTransportBidirectionalLikeV2>;
-    datagrams: WebTransportDatagramsLikeV2;
-    createBidirectionalStream(): Promise<WebTransportBidirectionalLikeV2>;
-    close(info?: Readonly<{
-        closeCode: number;
-        reason: string;
-    }>): void;
-}>;
-export declare function adaptWebTransportCarrierSessionV2(native: WebTransportSessionLikeV2, options: Readonly<{
-    path: PathKind;
-    inboundBidirectionalStreamCapacity: number;
-    datagramMaxSize?: number;
-}>): NativeCarrierSessionV2;
-export declare function hasWebTransportConstructorSurfaceV2(value: unknown): boolean;

package/dist/transport/webTransportAdapter.js

@@ -1,534 +0,0 @@
-import { CarrierError, } from "../v2/carrier.js";
-export function adaptWebTransportCarrierSessionV2(native, options) {
-    requireWebTransportSessionSurfaceV2(native);
-    return new WebTransportCarrierSessionAdapter(native, options);
-}
-export function hasWebTransportConstructorSurfaceV2(value) {
-    if (typeof value !== "function")
-        return false;
-    const prototype = value.prototype;
-    return typeof prototype === "object" && prototype !== null &&
-        typeof prototype.createBidirectionalStream === "function" &&
-        typeof prototype.close === "function" &&
-        "incomingBidirectionalStreams" in prototype &&
-        "datagrams" in prototype &&
-        "ready" in prototype &&
-        "closed" in prototype;
-}
-function requireWebTransportSessionSurfaceV2(value) {
-    const missing = [];
-    if (typeof value.createBidirectionalStream !== "function")
-        missing.push("outgoing bidirectional streams");
-    if (typeof value.incomingBidirectionalStreams?.getReader !== "function")
-        missing.push("incoming bidirectional streams");
-    if (typeof value.datagrams?.readable?.getReader !== "function")
-        missing.push("incoming DATAGRAMs");
-    if (typeof value.datagrams?.writable?.getWriter !== "function")
-        missing.push("outgoing DATAGRAMs");
-    if (typeof value.close !== "function")
-        missing.push("close");
-    if (typeof value.closed?.then !== "function")
-        missing.push("termination");
-    if (missing.length !== 0) {
-        throw new TypeError(`WebTransport runtime lacks required ${missing.join(", ")}`);
-    }
-}
-class WebTransportCarrierSessionAdapter {
-    native;
-    kind = "webtransport";
-    path;
-    inboundBidirectionalStreamCapacity;
-    unreliableDatagrams;
-    incoming;
-    incomingQueue = new IncomingWebTransportStreamQueue();
-    streams = new Set();
-    datagramsAdapter;
-    closed = false;
-    terminalError;
-    closePromise;
-    activeIncomingStreams = 0;
-    constructor(native, options) {
-        this.native = native;
-        if (!Number.isInteger(options.inboundBidirectionalStreamCapacity) || options.inboundBidirectionalStreamCapacity < 3) {
-            throw new RangeError("WebTransport carrier stream capacity must be at least 3");
-        }
-        this.path = options.path;
-        this.inboundBidirectionalStreamCapacity = options.inboundBidirectionalStreamCapacity;
-        this.incoming = native.incomingBidirectionalStreams.getReader();
-        this.datagramsAdapter = new WebTransportDatagramAdapter(native.datagrams, options.datagramMaxSize);
-        this.unreliableDatagrams = this.datagramsAdapter;
-        void this.pumpIncoming();
-        void native.closed.then(() => { this.terminate(new CarrierError("closed", "WebTransport carrier is closed")); }, (error) => {
-            this.terminate(carrierFailure("WebTransport closed with an error", error));
-        });
-    }
-    async openStream(options = {}) {
-        this.assertOpen();
-        if (options.signal?.aborted === true)
-            throw abortedCarrierError(options.signal.reason);
-        const pending = this.native.createBidirectionalStream();
-        let stream;
-        try {
-            stream = await carrierCall(raceAbort(pending, options.signal), "WebTransport failed to open a stream");
-        }
-        catch (error) {
-            if (isAborted(options.signal)) {
-                void pending.then((late) => abortNativeStream(late, abortedCarrierError()), () => undefined);
-            }
-            throw error;
-        }
-        try {
-            this.assertOpen();
-        }
-        catch (error) {
-            abortNativeStream(stream, asError(error));
-            throw error;
-        }
-        return this.track(stream);
-    }
-    async acceptStream(options = {}) {
-        this.assertOpen();
-        return await this.incomingQueue.shift(options.signal);
-    }
-    async waitTermination() {
-        try {
-            await this.native.closed;
-        }
-        catch (error) {
-            throw carrierFailure("WebTransport terminated with an error", error);
-        }
-    }
-    close() {
-        this.closePromise ??= this.closeOnce({ closeCode: 0, reason: "" });
-        return this.closePromise;
-    }
-    abort(error = { code: 6, reason: "carrier aborted" }) {
-        if (this.closed)
-            return;
-        this.terminate(new CarrierError("aborted", "WebTransport carrier aborted"));
-        try {
-            this.native.close({ closeCode: error.code, reason: error.reason });
-        }
-        catch (cause) {
-            this.terminalError = carrierFailure("WebTransport abort failed", cause);
-        }
-    }
-    async closeOnce(info) {
-        if (this.closed)
-            return;
-        this.terminate(new CarrierError("closed", "WebTransport carrier is closed"));
-        try {
-            this.native.close(info);
-            await this.native.closed;
-        }
-        catch (error) {
-            throw carrierFailure("WebTransport close failed", error);
-        }
-    }
-    assertOpen() {
-        if (this.terminalError !== undefined)
-            throw this.terminalError;
-        if (this.closed)
-            throw new CarrierError("closed", "WebTransport carrier is closed");
-    }
-    track(native, incoming = false) {
-        if (incoming)
-            this.activeIncomingStreams += 1;
-        let stream;
-        stream = new WebTransportCarrierStreamAdapter(native, () => {
-            this.streams.delete(stream);
-            if (incoming)
-                this.activeIncomingStreams = Math.max(0, this.activeIncomingStreams - 1);
-        });
-        this.streams.add(stream);
-        return stream;
-    }
-    async pumpIncoming() {
-        try {
-            while (!this.closed) {
-                const result = await this.incoming.read();
-                if (result.done || result.value === undefined) {
-                    this.terminate(new CarrierError("closed", "WebTransport incoming streams closed"));
-                    return;
-                }
-                if (this.activeIncomingStreams >= this.inboundBidirectionalStreamCapacity) {
-                    abortNativeStream(result.value, new CarrierError("reset", "WebTransport inbound stream capacity exceeded"));
-                    continue;
-                }
-                this.incomingQueue.push(this.track(result.value, true));
-            }
-        }
-        catch (error) {
-            if (!this.closed)
-                this.terminate(carrierFailure("WebTransport stream accept failed", error));
-        }
-    }
-    terminate(error) {
-        if (this.closed)
-            return;
-        this.closed = true;
-        if (error.code !== "closed")
-            this.terminalError = error;
-        this.incomingQueue.fail(error);
-        for (const stream of [...this.streams])
-            stream.abort(error);
-        this.streams.clear();
-        this.datagramsAdapter.abort(error);
-    }
-}
-class WebTransportCarrierStreamAdapter {
-    onRelease;
-    reader;
-    writer;
-    readClosed = false;
-    readStopError;
-    writeClosed = false;
-    terminalError;
-    closeWritePromise;
-    stopSendingPromise;
-    resetPromise;
-    released = false;
-    constructor(stream, onRelease) {
-        this.onRelease = onRelease;
-        this.reader = stream.readable.getReader();
-        this.writer = stream.writable.getWriter();
-    }
-    async read(options = {}) {
-        this.assertReadable();
-        if (this.readClosed)
-            return null;
-        const result = await carrierCall(raceAbort(this.reader.read(), options.signal), "WebTransport stream read failed", "reset");
-        if (result.done || result.value === undefined) {
-            this.readClosed = true;
-            this.releaseIfComplete();
-            return null;
-        }
-        return result.value.slice();
-    }
-    async write(data) {
-        this.assertNotTerminal();
-        if (this.writeClosed)
-            throw new CarrierError("write_closed", "WebTransport stream write side is closed");
-        await carrierCall(this.writer.write(data.slice()), "WebTransport stream write failed", "reset");
-        return data.byteLength;
-    }
-    closeWrite() {
-        if (this.closeWritePromise !== undefined)
-            return this.closeWritePromise;
-        this.assertNotTerminal();
-        this.writeClosed = true;
-        this.closeWritePromise = carrierCall(this.writer.close(), "WebTransport stream FIN failed", "reset")
-            .then(() => { this.releaseIfComplete(); });
-        return this.closeWritePromise;
-    }
-    stopSending() {
-        if (this.stopSendingPromise !== undefined)
-            return this.stopSendingPromise;
-        this.assertNotTerminal();
-        const stopped = new CarrierError("stop_sending", "WebTransport stream receive side stopped");
-        this.readClosed = true;
-        this.readStopError = stopped;
-        this.stopSendingPromise ??= carrierCall(this.reader.cancel(stopped), "WebTransport STOP_SENDING failed", "stop_sending").then(() => { this.releaseIfComplete(); });
-        return this.stopSendingPromise;
-    }
-    reset() {
-        this.resetPromise ??= this.resetOnce();
-        return this.resetPromise;
-    }
-    abort(error = new CarrierError("aborted", "WebTransport stream aborted")) {
-        if (this.terminalError !== undefined)
-            return;
-        this.terminalError = error instanceof CarrierError
-            ? error
-            : new CarrierError("aborted", "WebTransport stream aborted", error);
-        this.readClosed = true;
-        this.writeClosed = true;
-        void this.writer.abort(this.terminalError).catch(() => undefined);
-        void this.reader.cancel(this.terminalError).catch(() => undefined);
-        this.release();
-    }
-    async resetOnce() {
-        if (this.terminalError !== undefined)
-            return;
-        this.writeClosed = true;
-        this.readClosed = true;
-        const error = new CarrierError("reset", "WebTransport stream reset");
-        this.terminalError = error;
-        try {
-            await Promise.allSettled([this.writer.abort(error), this.reader.cancel(error)]);
-        }
-        finally {
-            this.release();
-        }
-    }
-    assertReadable() {
-        this.assertNotTerminal();
-        if (this.readStopError !== undefined)
-            throw this.readStopError;
-    }
-    assertNotTerminal() {
-        if (this.terminalError !== undefined)
-            throw this.terminalError;
-    }
-    releaseIfComplete() {
-        if (this.readClosed && this.writeClosed)
-            this.release();
-    }
-    release() {
-        if (this.released)
-            return;
-        this.released = true;
-        this.onRelease();
-    }
-}
-class WebTransportDatagramAdapter {
-    maxDatagramSize;
-    readable;
-    writable;
-    incoming = new IncomingDatagramQueue();
-    terminalError;
-    constructor(native, configuredMaxSize) {
-        const maxDatagramSize = configuredMaxSize ?? native.maxDatagramSize;
-        if (!Number.isInteger(maxDatagramSize) || maxDatagramSize < 1) {
-            throw new TypeError("WebTransport runtime did not provide a valid DATAGRAM size");
-        }
-        this.maxDatagramSize = maxDatagramSize;
-        this.readable = native.readable.getReader();
-        this.writable = native.writable.getWriter();
-        void this.pumpIncoming();
-    }
-    async send(data, options = {}) {
-        this.assertOpen();
-        if (options.signal?.aborted === true)
-            throw abortedCarrierError(options.signal.reason);
-        if (options.expiresAt !== undefined && options.expiresAt <= Date.now())
-            return "dropped_expired";
-        if (data.byteLength < 1 || data.byteLength > this.maxDatagramSize)
-            return "dropped_carrier";
-        try {
-            await raceAbort(this.writable.write(data.slice()), options.signal);
-            return "accepted";
-        }
-        catch (error) {
-            if (isAborted(options.signal))
-                throw abortedCarrierError(error);
-            if (this.terminalError !== undefined)
-                throw this.terminalError;
-            return "dropped_carrier";
-        }
-    }
-    async receive(options = {}) {
-        this.assertOpen();
-        return await this.incoming.shift(options.signal);
-    }
-    abort(error) {
-        if (this.terminalError !== undefined)
-            return;
-        this.terminalError = error;
-        this.incoming.fail(error);
-        void this.writable.abort(error).catch(() => undefined);
-        void this.readable.cancel(error).catch(() => undefined);
-    }
-    assertOpen() {
-        if (this.terminalError !== undefined)
-            throw this.terminalError;
-    }
-    async pumpIncoming() {
-        try {
-            while (this.terminalError === undefined) {
-                const result = await this.readable.read();
-                if (result.done || result.value === undefined) {
-                    this.abort(new CarrierError("closed", "WebTransport datagrams closed"));
-                    return;
-                }
-                if (result.value.byteLength < 1 || result.value.byteLength > this.maxDatagramSize)
-                    continue;
-                this.incoming.push(result.value.slice());
-            }
-        }
-        catch (error) {
-            if (this.terminalError === undefined) {
-                this.abort(carrierFailure("WebTransport datagram receive failed", error));
-            }
-        }
-    }
-}
-class IncomingWebTransportStreamQueue {
-    values = [];
-    waiters = new Set();
-    terminalError;
-    push(stream) {
-        if (this.terminalError !== undefined) {
-            stream.abort(this.terminalError);
-            return;
-        }
-        const waiter = this.waiters.values().next().value;
-        if (waiter === undefined)
-            this.values.push(stream);
-        else
-            waiter.deliver(stream);
-    }
-    shift(signal) {
-        if (signal?.aborted === true)
-            return Promise.reject(abortedCarrierError(signal.reason));
-        if (this.terminalError !== undefined)
-            return Promise.reject(this.terminalError);
-        const value = this.values.shift();
-        if (value !== undefined)
-            return Promise.resolve(value);
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const cleanup = () => {
-                this.waiters.delete(waiter);
-                signal?.removeEventListener("abort", abort);
-            };
-            const waiter = {
-                deliver: (stream) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    cleanup();
-                    resolve(stream);
-                },
-                fail: (error) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    cleanup();
-                    reject(error);
-                },
-            };
-            const abort = () => waiter.fail(abortedCarrierError(signal?.reason));
-            this.waiters.add(waiter);
-            signal?.addEventListener("abort", abort, { once: true });
-            if (signal?.aborted === true)
-                abort();
-        });
-    }
-    fail(error) {
-        if (this.terminalError !== undefined)
-            return;
-        this.terminalError = error;
-        for (const stream of this.values)
-            stream.abort(error);
-        this.values.length = 0;
-        for (const waiter of [...this.waiters])
-            waiter.fail(error);
-    }
-}
-class IncomingDatagramQueue {
-    static MAX_VALUES = 256;
-    static MAX_BYTES = 4 * 1024 * 1024;
-    values = [];
-    bufferedBytes = 0;
-    waiters = new Set();
-    terminalError;
-    push(value) {
-        if (this.terminalError !== undefined)
-            return;
-        const waiter = this.waiters.values().next().value;
-        if (waiter === undefined) {
-            // DATAGRAMs are lossy by contract. Drop an incoming value once the
-            // bounded queue budget is exhausted, while keeping the native reader
-            // drained so an unconsumed peer cannot grow memory without bound.
-            if (this.values.length >= IncomingDatagramQueue.MAX_VALUES ||
-                this.bufferedBytes + value.byteLength > IncomingDatagramQueue.MAX_BYTES)
-                return;
-            this.values.push(value);
-            this.bufferedBytes += value.byteLength;
-        }
-        else
-            waiter.deliver(value);
-    }
-    shift(signal) {
-        if (signal?.aborted === true)
-            return Promise.reject(abortedCarrierError(signal.reason));
-        if (this.terminalError !== undefined)
-            return Promise.reject(this.terminalError);
-        const value = this.values.shift();
-        if (value !== undefined) {
-            this.bufferedBytes -= value.byteLength;
-            return Promise.resolve(value);
-        }
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const cleanup = () => {
-                this.waiters.delete(waiter);
-                signal?.removeEventListener("abort", abort);
-            };
-            const waiter = {
-                deliver: (next) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    cleanup();
-                    resolve(next);
-                },
-                fail: (error) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    cleanup();
-                    reject(error);
-                },
-            };
-            const abort = () => waiter.fail(abortedCarrierError(signal?.reason));
-            this.waiters.add(waiter);
-            signal?.addEventListener("abort", abort, { once: true });
-            if (signal?.aborted === true)
-                abort();
-        });
-    }
-    fail(error) {
-        if (this.terminalError !== undefined)
-            return;
-        this.terminalError = error;
-        this.values.length = 0;
-        this.bufferedBytes = 0;
-        for (const waiter of [...this.waiters])
-            waiter.fail(error);
-    }
-}
-function abortNativeStream(stream, error) {
-    const reader = stream.readable.getReader();
-    const writer = stream.writable.getWriter();
-    void reader.cancel(error).catch(() => undefined);
-    void writer.abort(error).catch(() => undefined);
-}
-function abortedCarrierError(cause) {
-    return new CarrierError("aborted", "WebTransport operation aborted", cause);
-}
-function isAborted(signal) {
-    return signal?.aborted === true;
-}
-async function raceAbort(promise, signal) {
-    if (signal === undefined)
-        return await promise;
-    if (signal.aborted)
-        throw abortedCarrierError(signal.reason);
-    return await new Promise((resolve, reject) => {
-        const abort = () => reject(abortedCarrierError(signal.reason));
-        signal.addEventListener("abort", abort, { once: true });
-        void promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
-    });
-}
-async function carrierCall(promise, message, code = "closed") {
-    try {
-        return await promise;
-    }
-    catch (error) {
-        if (error instanceof CarrierError)
-            throw error;
-        if (error instanceof DOMException && error.name === "AbortError" ||
-            error instanceof Error && error.name === "AbortError") {
-            throw new CarrierError("aborted", message, error);
-        }
-        throw new CarrierError(code, message, error);
-    }
-}
-function carrierFailure(message, cause) {
-    return cause instanceof CarrierError ? cause : new CarrierError("closed", message, cause);
-}
-function asError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}

package/dist/v2/admissionError.d.ts

@@ -1,4 +0,0 @@
-export declare class AdmissionSessionV2Error extends Error {
-    readonly reason: string;
-    constructor(reason: string, message: string);
-}

package/dist/v2/admissionError.js

@@ -1,8 +0,0 @@
-export class AdmissionSessionV2Error extends Error {
-    reason;
-    constructor(reason, message) {
-        super(message);
-        this.reason = reason;
-        this.name = "AdmissionSessionV2Error";
-    }
-}

package/dist/v2/artifact.d.ts

@@ -1,128 +0,0 @@
-export type ArtifactCarrierV2 = "websocket" | "raw_quic" | "webtransport";
-export type ArtifactPathKindV2 = "direct" | "tunnel";
-export type ArtifactCandidateV2 = Readonly<{
-    id: string;
-    carrier: ArtifactCarrierV2;
-    url: string;
-    wire_profile: string;
-    normalized_url?: string;
-}>;
-export type CanonicalArtifactCandidateV2 = Readonly<{
-    carrier: ArtifactCarrierV2;
-    id: string;
-    normalized_url: string;
-    wire_profile: string;
-}>;
-export type SessionContractV2 = Readonly<{
-    channel_id: string;
-    init_expire_at_unix_s: number;
-    idle_timeout_seconds: number;
-    establish_timeout_seconds: number;
-    rekey_prepare_timeout_seconds: number;
-    rekey_completion_timeout_seconds: number;
-    max_inbound_streams: number;
-    e2ee_psk_b64u: string;
-    allowed_suites: readonly number[];
-    default_suite: number;
-    selected_features: number;
-    contract_hash_b64u: string;
-}>;
-export type DirectArtifactPathV2 = Readonly<{
-    kind: "direct";
-    rendezvous_group_id: string;
-    listener_audience: string;
-    routing_token: string;
-    candidates: readonly ArtifactCandidateV2[];
-}>;
-export type TunnelArtifactPathV2 = Readonly<{
-    kind: "tunnel";
-    rendezvous_group_id: string;
-    listener_audience: string;
-    role: 1 | 2;
-    local_endpoint_instance_id: string;
-    expected_peer_endpoint_instance_id: string;
-    token: string;
-    candidates: readonly ArtifactCandidateV2[];
-}>;
-export type ScopeMetadataV2 = Readonly<{
-    scope: string;
-    scope_version: number;
-    critical: boolean;
-    payload: Readonly<Record<string, unknown>>;
-}>;
-export type CorrelationTagV2 = Readonly<{
-    key: string;
-    value: string;
-}>;
-export type CorrelationContextV2 = Readonly<{
-    v: 2;
-    tags: readonly CorrelationTagV2[];
-}>;
-export type ArtifactV2 = Readonly<{
-    v: 2;
-    profile: "flowersec/2";
-    session: SessionContractV2;
-    path: DirectArtifactPathV2 | TunnelArtifactPathV2;
-    scoped: readonly ScopeMetadataV2[];
-    correlation: CorrelationContextV2;
-}>;
-type CommonFSB2RequestV2 = Readonly<{
-    profile: "flowersec/2";
-    channel_id: string;
-    session_contract_hash_b64u: string;
-    rendezvous_group_id: string;
-    candidates: readonly CanonicalArtifactCandidateV2[];
-    candidate_set_hash_b64u: string;
-    chosen_candidate_id: string;
-    listener_audience: string;
-}>;
-export type DirectFSB2RequestV2 = CommonFSB2RequestV2 & Readonly<{
-    pathKind: "direct";
-    routing_token: string;
-}>;
-export type TunnelFSB2RequestV2 = CommonFSB2RequestV2 & Readonly<{
-    pathKind: "tunnel";
-    role: 1 | 2;
-    endpoint_instance_id: string;
-    attach_token: string;
-}>;
-export type FSB2RequestV2 = DirectFSB2RequestV2 | TunnelFSB2RequestV2;
-export type DecodedFSB2RequestV2 = Readonly<{
-    request: FSB2RequestV2;
-    raw: Uint8Array;
-    localAdmissionBinding: Uint8Array;
-}>;
-export declare enum AdmissionStatusV2 {
-    Success = 0,
-    Reject = 1,
-    Retryable = 2
-}
-export type AdmissionResponseV2 = Readonly<{
-    status: AdmissionStatusV2;
-    reason: string;
-}>;
-export type ArtifactV2ErrorCode = "artifact_too_large" | "fsb2_payload_too_large" | "invalid_artifact" | "invalid_candidate" | "invalid_fsa2" | "invalid_fsb2" | "noncanonical_fsb2";
-export declare class ArtifactV2Error extends Error {
-    readonly code: ArtifactV2ErrorCode;
-    constructor(code: ArtifactV2ErrorCode, message: string);
-}
-export type LabeledHashV2 = Readonly<{
-    canonicalJSON: string;
-    hash: Uint8Array;
-    hashBase64URL: string;
-}>;
-export type CanonicalCandidateSetV2 = LabeledHashV2 & Readonly<{
-    candidates: readonly CanonicalArtifactCandidateV2[];
-}>;
-export declare function computeSessionContractHashV2(session: SessionContractV2): LabeledHashV2;
-export declare function canonicalizeCandidatesV2(kind: ArtifactPathKindV2, candidates: readonly ArtifactCandidateV2[]): CanonicalCandidateSetV2;
-export declare function decodeArtifactV2JSON(raw: string | Uint8Array): ArtifactV2;
-export declare function encodeArtifactV2JSON(artifact: ArtifactV2): Uint8Array;
-export declare function validateArtifactV2(artifact: ArtifactV2): CanonicalCandidateSetV2;
-export declare function buildFSB2RequestV2(artifact: ArtifactV2, chosenCandidateID: string): FSB2RequestV2;
-export declare function encodeFSB2RequestV2(request: FSB2RequestV2): Uint8Array;
-export declare function decodeFSB2RequestV2(raw: Uint8Array): DecodedFSB2RequestV2;
-export declare function admissionBindingV2(rawFSB2: Uint8Array): Uint8Array;
-export declare function encodeFSA2ResponseV2(response: AdmissionResponseV2): Uint8Array;
-export declare function decodeFSA2ResponseV2(raw: Uint8Array): AdmissionResponseV2;
-export {};