@qlever-llc/trellis 0.10.3-rc.2 → 0.10.3

package/esm/npm/src/device.js

@@ -1,549 +0,0 @@
-import "./_dnt.polyfills.js";
-import { jwtAuthenticator, } from "@nats-io/nats-core";
-import { AsyncResult, Result, UnexpectedError, } from "@qlever-llc/result";
-import { ulid } from "ulid";
-import { CONTRACT_STATE_METADATA, } from "./contract_support/mod.js";
-import { buildDeviceActivationPayload, deriveDeviceIdentity, signDeviceWaitRequest, startDeviceActivationRequest, verifyDeviceConfirmationCode, waitForDeviceActivation, } from "./auth/device_activation.js";
-import { importEd25519PrivateKeyFromSeedBase64url, signEd25519SeedSha256, } from "./auth/keys.js";
-import { base64urlDecode, base64urlEncode, toArrayBuffer, } from "./auth/utils.js";
-import { correctedIatSeconds, estimateMidpointClockOffsetMs, } from "./auth/time.js";
-import { buildNatsConnectSignaturePayload } from "./auth/session_auth.js";
-import { DEFAULT_RUNTIME_MAX_RECONNECT_ATTEMPTS, loadDefaultRuntimeTransport, selectRuntimeTransportServers, } from "./runtime_transport.js";
-import { ServiceHealth } from "./health.js";
-import { Trellis } from "./trellis.js";
-import { logger as noopLogger } from "./globals.js";
-import { TransportError } from "./errors/index.js";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
-import { observeNatsTrellisConnection, } from "./connection.js";
-function deviceConnectResult(promise) {
-    return AsyncResult.from(promise.then((value) => Result.ok(value), (cause) => Result.err(cause instanceof TransportError
-        ? cause
-        : new UnexpectedError({ cause }))));
-}
-const ClientTransportEndpointsSchema = Type.Object({
-    natsServers: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
-});
-const ClientTransportsSchema = Type.Object({
-    native: Type.Optional(ClientTransportEndpointsSchema),
-    websocket: Type.Optional(ClientTransportEndpointsSchema),
-});
-const DeviceBootstrapReadySchema = Type.Object({
-    status: Type.Literal("ready"),
-    connectInfo: Type.Object({
-        instanceId: Type.String({ minLength: 1 }),
-        deploymentId: Type.String({ minLength: 1 }),
-        contractId: Type.String({ minLength: 1 }),
-        contractDigest: Type.String({ minLength: 1 }),
-        transports: ClientTransportsSchema,
-        transport: Type.Object({
-            sentinel: Type.Object({
-                jwt: Type.String({ minLength: 1 }),
-                seed: Type.String({ minLength: 1 }),
-            }),
-        }),
-        auth: Type.Object({
-            mode: Type.Literal("device_identity"),
-            iatSkewSeconds: Type.Integer({ minimum: 1 }),
-        }),
-    }),
-});
-const DeviceBootstrapActivationRequiredSchema = Type.Object({
-    status: Type.Literal("activation_required"),
-});
-const DeviceBootstrapNotReadySchema = Type.Object({
-    status: Type.Literal("not_ready"),
-    reason: Type.String({ minLength: 1 }),
-});
-function normalizeRootSecret(rootSecret) {
-    if (typeof rootSecret === "string") {
-        const decoded = base64urlDecode(rootSecret.trim());
-        if (decoded.length === 0)
-            throw new Error("rootSecret must not be empty");
-        return decoded;
-    }
-    if (rootSecret.length === 0)
-        throw new Error("rootSecret must not be empty");
-    return rootSecret;
-}
-async function signIdentityBytes(identitySeed, data) {
-    const privateKey = await importEd25519PrivateKeyFromSeedBase64url(base64urlEncode(identitySeed));
-    return new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, toArrayBuffer(data)));
-}
-function createDeviceNatsAuthTokenAuthenticator(args) {
-    return () => {
-        const iat = correctedIatSeconds(args.now(), args.getServerClockOffsetMs());
-        const sig = signEd25519SeedSha256(args.identitySeed, new TextEncoder().encode(`nats-connect:${buildNatsConnectSignaturePayload(iat, args.contractDigest)}`));
-        return {
-            auth_token: JSON.stringify({
-                v: 1,
-                sessionKey: args.publicIdentityKey,
-                iat,
-                sig: base64urlEncode(new Uint8Array(sig)),
-                contractDigest: args.contractDigest,
-            }),
-        };
-    };
-}
-const defaultDeps = {
-    loadTransport: loadDefaultRuntimeTransport,
-    now: () => Date.now(),
-};
-function transportCauseContext(cause) {
-    if (cause instanceof Error) {
-        return { causeName: cause.name, causeMessage: cause.message };
-    }
-    return { cause: String(cause) };
-}
-function createTransportError(args) {
-    return new TransportError({
-        code: args.code,
-        message: args.message,
-        hint: args.hint,
-        cause: args.cause,
-        context: {
-            ...(args.context ?? {}),
-            ...(args.cause === undefined ? {} : transportCauseContext(args.cause)),
-        },
-    });
-}
-function assertBootstrapContractMatches(args) {
-    if (args.connectInfo.contractId !== args.contractId ||
-        args.connectInfo.contractDigest !== args.contractDigest) {
-        throw createTransportError({
-            code: "trellis.bootstrap.contract_mismatch",
-            message: "Trellis returned connection details for a different device contract.",
-            hint: "Retry the connection. If it keeps happening, check the requested device contract and Trellis activation state.",
-            context: {
-                requestedContractId: args.contractId,
-                requestedContractDigest: args.contractDigest,
-                returnedContractId: args.connectInfo.contractId,
-                returnedContractDigest: args.connectInfo.contractDigest,
-            },
-        });
-    }
-}
-async function readJsonResponse(response, args) {
-    try {
-        return await response.json();
-    }
-    catch (cause) {
-        throw createTransportError({
-            ...args,
-            cause,
-        });
-    }
-}
-function parseResponseRecord(text) {
-    if (text.length === 0) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(text);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-            ? parsed
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
-function resolveDeviceLogger(log) {
-    if (log === false) {
-        return noopLogger;
-    }
-    return log ?? noopLogger;
-}
-async function readResponseReason(response) {
-    const text = await response.text();
-    if (!text) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(text);
-        if (typeof parsed.reason === "string" && parsed.reason.length > 0) {
-            return parsed.reason;
-        }
-    }
-    catch {
-        return text;
-    }
-    return text;
-}
-function createActivationRequiredTransportError(context) {
-    return createTransportError({
-        code: "trellis.bootstrap.activation_required",
-        message: "Trellis requires device activation before connecting.",
-        hint: "Start or resume device activation, then retry the runtime connection after activation completes.",
-        context,
-    });
-}
-function createInvalidConfirmationCodeTransportError(context) {
-    return createTransportError({
-        code: "trellis.device.invalid_confirmation_code",
-        message: "The device confirmation code is invalid.",
-        hint: "Retry with the current confirmation code for this activation, or restart activation if the code is no longer valid.",
-        context,
-    });
-}
-function createActivatedLocalState(localState) {
-    return {
-        ...localState,
-        status: "activated",
-    };
-}
-function assertActivationStateMatchesIdentity(args) {
-    if (args.localState.publicIdentityKey !== args.publicIdentityKey) {
-        throw createTransportError({
-            code: "trellis.device.activation_state_mismatch",
-            message: "Local device activation state does not match the provided root secret.",
-            hint: "Use the activation state for the same device identity, or start a new activation for this root secret.",
-            context: {
-                statePublicIdentityKey: args.localState.publicIdentityKey,
-                publicIdentityKey: args.publicIdentityKey,
-            },
-        });
-    }
-}
-function assertActivationStateMatchesContract(args) {
-    if (args.localState.contractDigest !== args.contractDigest) {
-        throw createTransportError({
-            code: "trellis.device.activation_state_contract_mismatch",
-            message: "Local device activation state does not match the requested device contract.",
-            hint: "Use activation state for the same device contract, or start activation again for this contract digest.",
-            context: {
-                stateContractDigest: args.localState.contractDigest,
-                contractDigest: args.contractDigest,
-            },
-        });
-    }
-}
-async function createActivationSession(args) {
-    assertActivationStateMatchesIdentity({
-        localState: args.localState,
-        publicIdentityKey: args.identity.publicIdentityKey,
-    });
-    assertActivationStateMatchesContract({
-        localState: args.localState,
-        contractDigest: args.contractDigest,
-    });
-    const activatedState = createActivatedLocalState(args.localState);
-    return {
-        activationUrl: args.localState.activationUrl,
-        localState: args.localState,
-        waitForOnlineApproval: async (opts) => {
-            if (args.localState.status === "activated") {
-                return activatedState;
-            }
-            await waitForDeviceActivation({
-                trellisUrl: args.trellisUrl,
-                flowId: args.localState.flowId,
-                publicIdentityKey: args.identity.publicIdentityKey,
-                nonce: args.localState.nonce,
-                identitySeed: args.identity.identitySeed,
-                contractDigest: args.contractDigest,
-                signal: opts?.signal,
-            });
-            return activatedState;
-        },
-        acceptConfirmationCode: async (code) => {
-            if (args.localState.status === "activated") {
-                return activatedState;
-            }
-            const ok = await verifyDeviceConfirmationCode({
-                activationKey: args.identity.activationKey,
-                publicIdentityKey: args.identity.publicIdentityKey,
-                nonce: args.localState.nonce,
-                confirmationCode: code,
-            });
-            if (!ok) {
-                throw createInvalidConfirmationCodeTransportError({
-                    publicIdentityKey: args.identity.publicIdentityKey,
-                    instanceId: args.localState.instanceId,
-                    deploymentId: args.localState.deploymentId,
-                });
-            }
-            return activatedState;
-        },
-    };
-}
-async function fetchDeviceBootstrap(args) {
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        const requestStartedAtMs = args.now();
-        const request = await signDeviceWaitRequest({
-            flowId: "connect-info",
-            publicIdentityKey: args.publicIdentityKey,
-            nonce: "connect-info",
-            identitySeed: args.identitySeed,
-            contractDigest: args.contractDigest,
-            iat: correctedIatSeconds(requestStartedAtMs, args.offsetState.serverClockOffsetMs),
-        });
-        const bootstrapRequest = {
-            publicIdentityKey: request.publicIdentityKey,
-            contractDigest: request.contractDigest,
-            iat: request.iat,
-            sig: request.sig,
-        };
-        const response = await fetch(new URL("/auth/devices/connect-info", args.trellisUrl), {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(bootstrapRequest),
-        });
-        const responseReceivedAtMs = args.now();
-        if (!response.ok) {
-            const responseText = await response.text();
-            const parsed = parseResponseRecord(responseText);
-            const reason = typeof parsed?.reason === "string"
-                ? parsed.reason
-                : responseText;
-            const serverNow = typeof parsed?.serverNow === "number"
-                ? parsed.serverNow
-                : null;
-            if (attempt === 0 &&
-                response.status === 400 &&
-                reason === "iat_out_of_range" &&
-                serverNow !== null) {
-                args.offsetState.serverClockOffsetMs = estimateMidpointClockOffsetMs({
-                    requestStartedAtMs,
-                    responseReceivedAtMs,
-                    serverNowSeconds: serverNow,
-                });
-                continue;
-            }
-            if (response.status === 404 &&
-                (reason === "unknown_device" || reason === "activation_required")) {
-                return { status: "activation_required" };
-            }
-            throw createTransportError({
-                code: "trellis.bootstrap.failed",
-                message: "Trellis could not prepare the device session.",
-                hint: "Retry the connection. If it keeps failing, check Trellis availability and device activation state.",
-                context: {
-                    trellisUrl: args.trellisUrl,
-                    status: response.status,
-                    reason,
-                },
-            });
-        }
-        const payload = await readJsonResponse(response, {
-            code: "trellis.bootstrap.invalid_response",
-            message: "Trellis returned an invalid bootstrap response.",
-            hint: "Retry the connection. If it keeps happening, check the Trellis deployment.",
-            context: { trellisUrl: args.trellisUrl },
-        });
-        if (payload && typeof payload === "object" &&
-            typeof payload.serverNow === "number") {
-            args.offsetState.serverClockOffsetMs = estimateMidpointClockOffsetMs({
-                requestStartedAtMs,
-                responseReceivedAtMs,
-                serverNowSeconds: payload.serverNow,
-            });
-        }
-        if (Value.Check(DeviceBootstrapReadySchema, payload))
-            return payload;
-        if (Value.Check(DeviceBootstrapActivationRequiredSchema, payload)) {
-            return payload;
-        }
-        if (Value.Check(DeviceBootstrapNotReadySchema, payload))
-            return payload;
-        throw createTransportError({
-            code: "trellis.bootstrap.invalid_response",
-            message: "Trellis returned an invalid bootstrap response.",
-            hint: "Retry the connection. If it keeps happening, check the Trellis deployment.",
-            context: { trellisUrl: args.trellisUrl },
-        });
-    }
-    throw createTransportError({
-        code: "trellis.bootstrap.time_sync_failed",
-        message: "Trellis could not confirm the device time window.",
-        hint: "Retry the connection. If it keeps happening, check the device and Trellis clocks.",
-        context: { trellisUrl: args.trellisUrl },
-    });
-}
-export async function startDeviceActivationWithDeps(args, _deps) {
-    const rootSecret = normalizeRootSecret(args.rootSecret);
-    const identity = await deriveDeviceIdentity(rootSecret);
-    const nonce = ulid();
-    const payload = await buildDeviceActivationPayload({
-        activationKey: identity.activationKey,
-        publicIdentityKey: identity.publicIdentityKey,
-        nonce,
-    });
-    const activation = await startDeviceActivationRequest({
-        trellisUrl: args.trellisUrl,
-        payload,
-    });
-    return await createActivationSession({
-        trellisUrl: args.trellisUrl,
-        contractDigest: args.contract.CONTRACT_DIGEST,
-        identity,
-        localState: {
-            status: "pending",
-            contractDigest: args.contract.CONTRACT_DIGEST,
-            publicIdentityKey: identity.publicIdentityKey,
-            instanceId: activation.instanceId,
-            deploymentId: activation.deploymentId,
-            flowId: activation.flowId,
-            nonce,
-            activationUrl: activation.activationUrl,
-        },
-    });
-}
-export async function resumeDeviceActivationWithDeps(args, _deps) {
-    const rootSecret = normalizeRootSecret(args.rootSecret);
-    const identity = await deriveDeviceIdentity(rootSecret);
-    return await createActivationSession({
-        trellisUrl: args.trellisUrl,
-        contractDigest: args.contract.CONTRACT_DIGEST,
-        identity,
-        localState: args.localState,
-    });
-}
-export async function connectDeviceWithDeps(args, deps) {
-    const log = resolveDeviceLogger(args.log);
-    const rootSecret = normalizeRootSecret(args.rootSecret);
-    const identity = await deriveDeviceIdentity(rootSecret);
-    const contractDigest = args.contract.CONTRACT_DIGEST;
-    const offsetState = { serverClockOffsetMs: 0 };
-    const bootstrap = await fetchDeviceBootstrap({
-        trellisUrl: args.trellisUrl,
-        publicIdentityKey: identity.publicIdentityKey,
-        identitySeed: identity.identitySeed,
-        contractDigest,
-        now: deps.now,
-        offsetState,
-    });
-    if (bootstrap.status === "activation_required") {
-        throw createActivationRequiredTransportError({
-            publicIdentityKey: identity.publicIdentityKey,
-            contractId: args.contract.CONTRACT_ID,
-        });
-    }
-    if (bootstrap.status === "not_ready") {
-        throw createTransportError({
-            code: "trellis.bootstrap.not_ready",
-            message: "Trellis is not ready to connect this device.",
-            hint: "Wait for the device to be activated and the requested deployment to become available, then try again.",
-            context: { reason: bootstrap.reason },
-        });
-    }
-    const connectInfo = bootstrap.connectInfo;
-    assertBootstrapContractMatches({
-        contractId: args.contract.CONTRACT_ID,
-        contractDigest,
-        connectInfo,
-    });
-    const transport = await deps.loadTransport();
-    let nc;
-    try {
-        nc = await transport.connect({
-            servers: selectRuntimeTransportServers(connectInfo.transports),
-            maxReconnectAttempts: DEFAULT_RUNTIME_MAX_RECONNECT_ATTEMPTS,
-            inboxPrefix: `_INBOX.${identity.publicIdentityKey.slice(0, 16)}`,
-            authenticator: [
-                createDeviceNatsAuthTokenAuthenticator({
-                    publicIdentityKey: identity.publicIdentityKey,
-                    identitySeed: identity.identitySeed,
-                    contractDigest,
-                    now: deps.now,
-                    getServerClockOffsetMs: () => offsetState.serverClockOffsetMs,
-                }),
-                jwtAuthenticator(connectInfo.transport.sentinel.jwt, new TextEncoder().encode(connectInfo.transport.sentinel.seed)),
-            ],
-        });
-    }
-    catch (cause) {
-        throw createTransportError({
-            code: "trellis.runtime.connect_failed",
-            message: "Trellis could not open the device runtime connection.",
-            hint: "Retry the connection. If it keeps failing, check Trellis transport availability.",
-            cause,
-            context: { contractId: args.contract.CONTRACT_ID },
-        });
-    }
-    const connection = observeNatsTrellisConnection({
-        kind: "device",
-        nc,
-        log: false,
-        lifecycleLog: {
-            log,
-            context: { contractId: args.contract.CONTRACT_ID },
-        },
-    });
-    const trellis = new Trellis(args.contract.CONTRACT_ID, nc, {
-        sessionKey: identity.publicIdentityKey,
-        sign: (data) => signIdentityBytes(identity.identitySeed, data),
-    }, {
-        log,
-        api: args.contract.API.trellis,
-        state: args.contract[CONTRACT_STATE_METADATA],
-        connection,
-    });
-    const health = new ServiceHealth({
-        serviceName: args.contract.CONTRACT?.displayName ??
-            args.contract.CONTRACT_ID,
-        kind: "device",
-        instanceId: connectInfo.instanceId,
-        contractId: connectInfo.contractId,
-        contractDigest: connectInfo.contractDigest,
-        publishIntervalMs: 30_000,
-    });
-    health.setInfo({
-        info: {
-            deploymentId: connectInfo.deploymentId,
-        },
-    });
-    health.add("nats", () => ({
-        status: nc.isClosed() ? "failed" : "ok",
-        ...(nc.isClosed() ? { summary: "NATS connection closed" } : {}),
-    }));
-    const heartbeatEventEnabled = Boolean(args.contract.API.trellis.events?.["Health.Heartbeat"]);
-    let heartbeatTimer;
-    let publishingHeartbeat = false;
-    const stopHeartbeat = () => {
-        if (heartbeatTimer !== undefined) {
-            clearInterval(heartbeatTimer);
-            heartbeatTimer = undefined;
-        }
-    };
-    const publishHeartbeat = async () => {
-        if (!heartbeatEventEnabled || publishingHeartbeat) {
-            return;
-        }
-        publishingHeartbeat = true;
-        try {
-            const heartbeat = await health.heartbeat();
-            await trellis.publish("Health.Heartbeat", heartbeat);
-        }
-        finally {
-            publishingHeartbeat = false;
-        }
-    };
-    if (heartbeatEventEnabled) {
-        await publishHeartbeat();
-        heartbeatTimer = setInterval(() => {
-            void publishHeartbeat();
-        }, health.publishIntervalMs);
-        void nc.closed().finally(stopHeartbeat);
-    }
-    return {
-        request: trellis.request.bind(trellis),
-        publish: trellis.publish.bind(trellis),
-        event: trellis.event,
-        operation: trellis.operation,
-        transfer: trellis.transfer.bind(trellis),
-        state: trellis.state,
-        name: trellis.name,
-        timeout: trellis.timeout,
-        stream: trellis.stream,
-        api: trellis.api,
-        connection: trellis.connection,
-        natsConnection: trellis.natsConnection,
-        health,
-    };
-}
-export const TrellisDevice = {
-    connect(args) {
-        return deviceConnectResult(connectDeviceWithDeps(args, defaultDeps));
-    },
-};

package/esm/npm/src/env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC"}

package/esm/npm/src/errors/AuthError.d.ts

@@ -1,31 +0,0 @@
-import Type, { type Static } from "typebox";
-import { TrellisError } from "./TrellisError.js";
-export declare const AuthErrorDataSchema: Type.TObject<{
-    id: Type.TString;
-    type: Type.TLiteral<"AuthError">;
-    message: Type.TString;
-    reason: Type.TUnion<[Type.TLiteral<"invalid_request">, Type.TLiteral<"missing_session_key">, Type.TLiteral<"missing_proof">, Type.TLiteral<"session_not_found">, Type.TLiteral<"session_expired">, Type.TLiteral<"invalid_signature">, Type.TLiteral<"user_not_found">, Type.TLiteral<"user_already_exists">, Type.TLiteral<"username_taken">, Type.TLiteral<"identity_already_exists">, Type.TLiteral<"identity_not_found">, Type.TLiteral<"user_inactive">, Type.TLiteral<"unknown_device">, Type.TLiteral<"device_deployment_not_found">, Type.TLiteral<"device_deployment_disabled">, Type.TLiteral<"device_activation_revoked">, Type.TLiteral<"unknown_service">, Type.TLiteral<"service_disabled">, Type.TLiteral<"iat_out_of_range">, Type.TLiteral<"invalid_binding_token">, Type.TLiteral<"session_corrupted">, Type.TLiteral<"session_already_bound">, Type.TLiteral<"authtoken_already_used">, Type.TLiteral<"oauth_session_key_mismatch">, Type.TLiteral<"reply_subject_mismatch">, Type.TLiteral<"insufficient_permissions">, Type.TLiteral<"forbidden">, Type.TLiteral<"last_admin_required">, Type.TLiteral<"missing_flow_id">, Type.TLiteral<"device_activation_flow_not_found">, Type.TLiteral<"device_activation_flow_expired">, Type.TLiteral<"device_activation_rejected">, Type.TLiteral<"device_identity_key_mismatch">, Type.TLiteral<"invalid_device_qr_mac">]>;
-    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
-    traceId: Type.TOptional<Type.TString>;
-}>;
-export type AuthErrorData = Static<typeof AuthErrorDataSchema>;
-/**
- * Error for authentication and authorization failures.
- */
-export declare class AuthError extends TrellisError<AuthErrorData> {
-    readonly name: "AuthError";
-    readonly reason: AuthErrorData["reason"];
-    constructor(options: ErrorOptions & {
-        reason: AuthErrorData["reason"];
-        message?: string;
-        context?: Record<string, unknown>;
-        id?: string;
-    });
-    /**
-     * Serializes error to a plain object.
-     *
-     * @returns Plain object representation of the error
-     */
-    toSerializable(): AuthErrorData;
-}
-//# sourceMappingURL=AuthError.d.ts.map

package/esm/npm/src/errors/AuthError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AuthError.d.ts","sourceRoot":"","sources":["../../../../src/errors/AuthError.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,mBAAmB;;;;;;;EA0C9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE/D;;GAEG;AACH,qBAAa,SAAU,SAAQ,YAAY,CAAC,aAAa,CAAC;IACxD,SAAkB,IAAI,EAAG,WAAW,CAAU;IAC9C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;gBAGvC,OAAO,EAAE,YAAY,GAAG;QACtB,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;QAChC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb;IAOH;;;;OAIG;IACM,cAAc,IAAI,aAAa;CAOzC"}

package/esm/npm/src/errors/AuthError.js

@@ -1,79 +0,0 @@
-import Type from "typebox";
-import { TrellisError } from "./TrellisError.js";
-export const AuthErrorDataSchema = Type.Object({
-    id: Type.String(),
-    type: Type.Literal("AuthError"),
-    message: Type.String(),
-    reason: Type.Union([
-        Type.Literal("invalid_request"),
-        Type.Literal("missing_session_key"),
-        Type.Literal("missing_proof"),
-        Type.Literal("session_not_found"),
-        Type.Literal("session_expired"),
-        Type.Literal("invalid_signature"),
-        Type.Literal("user_not_found"),
-        Type.Literal("user_already_exists"),
-        Type.Literal("username_taken"),
-        Type.Literal("identity_already_exists"),
-        Type.Literal("identity_not_found"),
-        Type.Literal("user_inactive"),
-        Type.Literal("unknown_device"),
-        Type.Literal("device_deployment_not_found"),
-        Type.Literal("device_deployment_disabled"),
-        Type.Literal("device_activation_revoked"),
-        Type.Literal("unknown_service"),
-        Type.Literal("service_disabled"),
-        Type.Literal("iat_out_of_range"),
-        Type.Literal("invalid_binding_token"),
-        Type.Literal("session_corrupted"),
-        Type.Literal("session_already_bound"),
-        Type.Literal("authtoken_already_used"),
-        Type.Literal("oauth_session_key_mismatch"),
-        Type.Literal("reply_subject_mismatch"),
-        Type.Literal("insufficient_permissions"),
-        Type.Literal("forbidden"),
-        Type.Literal("last_admin_required"),
-        Type.Literal("missing_flow_id"),
-        Type.Literal("device_activation_flow_not_found"),
-        Type.Literal("device_activation_flow_expired"),
-        Type.Literal("device_activation_rejected"),
-        Type.Literal("device_identity_key_mismatch"),
-        Type.Literal("invalid_device_qr_mac"),
-    ]),
-    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-    traceId: Type.Optional(Type.String()),
-});
-/**
- * Error for authentication and authorization failures.
- */
-export class AuthError extends TrellisError {
-    constructor(options) {
-        const { reason, message, ...baseOptions } = options;
-        super(message ?? `Auth failed: ${reason}`, baseOptions);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "AuthError"
-        });
-        Object.defineProperty(this, "reason", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.reason = reason;
-    }
-    /**
-     * Serializes error to a plain object.
-     *
-     * @returns Plain object representation of the error
-     */
-    toSerializable() {
-        return {
-            ...this.baseSerializable(),
-            type: this.name,
-            reason: this.reason,
-        };
-    }
-}