sst 2.13.2 → 2.13.4

package/config.d.ts

@@ -1,4 +1,4 @@
-import { FunctionMetadata, SsrSiteMetadata } from "./constructs/Metadata.js";
+import { FunctionMetadata, NextjsSiteMetadata, AstroSiteMetadata, RemixSiteMetadata, SolidStartSiteMetadata, SvelteKitSiteMetadata, SSRSiteMetadata } from "./constructs/Metadata.js";
 declare module "./bus.js" {
     interface Events {
         "config.secret.updated": {
@@ -47,9 +47,9 @@ export declare namespace Config {
         fallback?: boolean;
     }): Promise<void>;
     function restart(keys: string[]): Promise<{
-        edgeSites: SsrSiteMetadata[];
-        sites: SsrSiteMetadata[];
-        placeholderSites: SsrSiteMetadata[];
+        edgeSites: (NextjsSiteMetadata | AstroSiteMetadata | RemixSiteMetadata | SolidStartSiteMetadata | SvelteKitSiteMetadata)[];
+        sites: SSRSiteMetadata[];
+        placeholderSites: (NextjsSiteMetadata | AstroSiteMetadata | RemixSiteMetadata | SolidStartSiteMetadata | SvelteKitSiteMetadata)[];
         functions: FunctionMetadata[];
     }>;
 }

package/constructs/AstroSite.d.ts

@@ -22,4 +22,16 @@ export declare class AstroSite extends SsrSite {
     protected validateBuildOutput(): void;
     protected createFunctionForRegional(): CdkFunction;
     protected createFunctionForEdge(): EdgeFunction;
+    getConstructMetadata(): {
+        data: {
+            mode: "placeholder" | "deployed";
+            path: string;
+            customDomainUrl: string | undefined;
+            url: string | undefined;
+            edge: boolean | undefined;
+            server: string;
+            secrets: string[];
+        };
+        type: "AstroSite";
+    };
 }

package/constructs/AstroSite.js

@@ -67,4 +67,10 @@ export class AstroSite extends SsrSite {
             },
         });
     }
+    getConstructMetadata() {
+        return {
+            type: "AstroSite",
+            ...this.getConstructMetadataBase(),
+        };
+    }
 }

package/constructs/Job.d.ts

@@ -211,7 +211,9 @@ export declare class Job extends Construct implements SSTConstruct {
     constructor(scope: Construct, id: string, props: JobProps);
     getConstructMetadata(): {
         type: "Job";
-        data: {};
+        data: {
+            handler: string;
+        };
     };
     /** @internal */
     getFunctionBinding(): FunctionBindingProps;

package/constructs/Job.js

@@ -75,7 +75,9 @@ export class Job extends Construct {
     getConstructMetadata() {
         return {
             type: "Job",
-            data: {},
+            data: {
+                handler: this.props.handler,
+            },
         };
     }
     /** @internal */

package/constructs/Metadata.d.ts

@@ -9,7 +9,7 @@ export type ApiMetadata = ExtractMetadata<Api<any>>;
 import type { ApiGatewayV1Api } from "./ApiGatewayV1Api.js";
 export type ApiGatewayV1ApiMetadata = ExtractMetadata<ApiGatewayV1Api<any>>;
 import type { Cognito } from "./Cognito.js";
-export type AuthMetadata = ExtractMetadata<Cognito>;
+export type CognitoMetadata = ExtractMetadata<Cognito>;
 import type { AppSyncApi } from "./AppSyncApi.js";
 export type AppSyncApiMetadata = ExtractMetadata<AppSyncApi>;
 import type { Bucket } from "./Bucket.js";
@@ -22,16 +22,12 @@ import type { Function as Fn } from "./Function.js";
 export type FunctionMetadata = ExtractMetadata<Fn>;
 import type { KinesisStream } from "./KinesisStream.js";
 export type KinesisStreamMetadata = ExtractMetadata<KinesisStream>;
-import type { NextjsSite } from "./NextjsSite.js";
-export type NextjsMetadata = ExtractMetadata<NextjsSite>;
 import type { NextjsSite as SlsNextjsSite } from "./deprecated/NextjsSite.js";
 export type SlsNextjsMetadata = ExtractMetadata<SlsNextjsSite>;
 import type { Queue } from "./Queue.js";
 export type QueueMetadata = ExtractMetadata<Queue>;
 import type { StaticSite } from "./StaticSite.js";
 export type StaticSiteMetadata = ExtractMetadata<StaticSite>;
-import type { SsrSite } from "./SsrSite.js";
-export type SsrSiteMetadata = ExtractMetadata<SsrSite>;
 import type { Table } from "./Table.js";
 export type TableMetadata = ExtractMetadata<Table>;
 import type { Topic } from "./Topic.js";
@@ -40,5 +36,16 @@ import type { WebSocketApi } from "./WebSocketApi.js";
 export type WebSocketApiMetadata = ExtractMetadata<WebSocketApi>;
 import type { RDS } from "./RDS.js";
 export type RDSMetadata = ExtractMetadata<RDS>;
-export type Metadata = ApiMetadata | ApiGatewayV1ApiMetadata | AuthMetadata | AppSyncApiMetadata | BucketMetadata | CronMetadata | EventBusMetadata | FunctionMetadata | KinesisStreamMetadata | NextjsMetadata | SlsNextjsMetadata | QueueMetadata | StaticSiteMetadata | SsrSiteMetadata | TableMetadata | TopicMetadata | WebSocketApiMetadata | RDSMetadata;
+import type { NextjsSite } from "./NextjsSite.js";
+export type NextjsSiteMetadata = ExtractMetadata<NextjsSite>;
+import type { AstroSite } from "./AstroSite.js";
+export type AstroSiteMetadata = ExtractMetadata<AstroSite>;
+import type { RemixSite } from "./RemixSite.js";
+export type RemixSiteMetadata = ExtractMetadata<RemixSite>;
+import type { SvelteKitSite } from "./SvelteKitSite.js";
+export type SvelteKitSiteMetadata = ExtractMetadata<SvelteKitSite>;
+import type { SolidStartSite } from "./SolidStartSite.js";
+export type SolidStartSiteMetadata = ExtractMetadata<SolidStartSite>;
+export type SSRSiteMetadata = NextjsSiteMetadata | AstroSiteMetadata | RemixSiteMetadata | SolidStartSiteMetadata | SvelteKitSiteMetadata;
+export type Metadata = ApiMetadata | ApiGatewayV1ApiMetadata | CognitoMetadata | AppSyncApiMetadata | BucketMetadata | CronMetadata | EventBusMetadata | FunctionMetadata | KinesisStreamMetadata | SlsNextjsMetadata | QueueMetadata | StaticSiteMetadata | TableMetadata | TopicMetadata | WebSocketApiMetadata | RDSMetadata | SSRSiteMetadata;
 export {};

package/constructs/NextjsSite.d.ts

@@ -61,4 +61,16 @@ export declare class NextjsSite extends SsrSite {
     private buildDefaultNextjsBehaviorForRegional;
     private buildDefaultNextjsBehaviorForEdge;
     protected generateBuildId(): string;
+    getConstructMetadata(): {
+        data: {
+            mode: "placeholder" | "deployed";
+            path: string;
+            customDomainUrl: string | undefined;
+            url: string | undefined;
+            edge: boolean | undefined;
+            server: string;
+            secrets: string[];
+        };
+        type: "NextjsSite";
+    };
 }

package/constructs/NextjsSite.js

@@ -383,4 +383,10 @@ export class NextjsSite extends SsrSite {
         const filePath = path.join(this.props.path, ".next/BUILD_ID");
         return fs.readFileSync(filePath).toString();
     }
+    getConstructMetadata() {
+        return {
+            type: "NextjsSite",
+            ...this.getConstructMetadataBase(),
+        };
+    }
 }

package/constructs/RemixSite.d.ts

@@ -24,4 +24,16 @@ export declare class RemixSite extends SsrSite {
     private createServerLambdaBundle;
     protected createFunctionForRegional(): CdkFunction;
     protected createFunctionForEdge(): EdgeFunction;
+    getConstructMetadata(): {
+        data: {
+            mode: "placeholder" | "deployed";
+            path: string;
+            customDomainUrl: string | undefined;
+            url: string | undefined;
+            edge: boolean | undefined;
+            server: string;
+            secrets: string[];
+        };
+        type: "RemixSite";
+    };
 }

package/constructs/RemixSite.js

@@ -137,4 +137,10 @@ export class RemixSite extends SsrSite {
             },
         });
     }
+    getConstructMetadata() {
+        return {
+            type: "RemixSite",
+            ...this.getConstructMetadataBase(),
+        };
+    }
 }

package/constructs/Script.d.ts

@@ -99,7 +99,7 @@ export interface ScriptProps {
  * });
  * ```
  */
-export declare class Script extends Construct {
+export declare class Script extends Construct implements SSTConstruct {
     /**
      * The internally created onCreate `Function` instance.
      */
@@ -113,6 +113,7 @@ export declare class Script extends Construct {
      */
     readonly deleteFunction?: Fn;
     protected readonly props: ScriptProps;
+    readonly id: string;
     constructor(scope: Construct, id: string, props: ScriptProps);
     /**
      * Binds additional resources to the script
@@ -136,4 +137,24 @@ export declare class Script extends Construct {
     private createCustomResourceFunction;
     private createCustomResource;
     private checkDeprecatedFunction;
+    /** @internal */
+    getConstructMetadata(): {
+        type: "Script";
+        data: {
+            createfn: {
+                node: string;
+                stack: string;
+            } | undefined;
+            deletefn: {
+                node: string;
+                stack: string;
+            } | undefined;
+            updatefn: {
+                node: string;
+                stack: string;
+            } | undefined;
+        };
+    };
+    /** @internal */
+    getFunctionBinding(): undefined;
 }

package/constructs/Script.js

@@ -2,8 +2,11 @@ import path from "path";
 import url from "url";
 import { Construct } from "constructs";
 import { CustomResource, Duration } from "aws-cdk-lib/core";
-import * as lambda from "aws-cdk-lib/aws-lambda";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { Code, Runtime, Function as CdkFunction } from "aws-cdk-lib/aws-lambda";
+import { Stack } from "./Stack.js";
 import { Function as Fn, } from "./Function.js";
+import { getFunctionRef, } from "./Construct.js";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 /////////////////////
 // Construct
@@ -37,8 +40,10 @@ export class Script extends Construct {
      */
     deleteFunction;
     props;
+    id;
     constructor(scope, id, props) {
         super(scope, id);
+        this.id = id;
         if (props.function)
             this.checkDeprecatedFunction();
         // Validate deprecated "function" prop
@@ -112,12 +117,18 @@ export class Script extends Construct {
         });
     }
     createCustomResourceFunction() {
-        const handler = new lambda.Function(this, "ScriptHandler", {
-            code: lambda.Code.fromAsset(path.join(__dirname, "../support/script-function")),
-            runtime: lambda.Runtime.NODEJS_16_X,
+        const handler = new CdkFunction(this, "ScriptHandler", {
+            code: Code.fromAsset(path.join(__dirname, "../support/script-function")),
+            runtime: Runtime.NODEJS_16_X,
             handler: "index.handler",
             timeout: Duration.minutes(15),
             memorySize: 1024,
+            initialPolicy: [
+                new PolicyStatement({
+                    actions: ["cloudformation:DescribeStacks"],
+                    resources: [Stack.of(this).stackId],
+                }),
+            ],
         });
         this.createFunction?.grantInvoke(handler);
         this.updateFunction?.grantInvoke(handler);
@@ -151,4 +162,19 @@ export class Script extends Construct {
     checkDeprecatedFunction() {
         throw new Error(`The "function" property has been replaced by "onCreate" and "onUpdate". More details on upgrading - https://docs.sst.dev/constructs/Script#upgrading-to-v0460`);
     }
+    /** @internal */
+    getConstructMetadata() {
+        return {
+            type: "Script",
+            data: {
+                createfn: getFunctionRef(this.createFunction),
+                deletefn: getFunctionRef(this.deleteFunction),
+                updatefn: getFunctionRef(this.updateFunction),
+            },
+        };
+    }
+    /** @internal */
+    getFunctionBinding() {
+        return undefined;
+    }
 }

package/constructs/SolidStartSite.d.ts

@@ -21,4 +21,16 @@ export declare class SolidStartSite extends SsrSite {
     };
     protected createFunctionForRegional(): CdkFunction;
     protected createFunctionForEdge(): EdgeFunction;
+    getConstructMetadata(): {
+        data: {
+            mode: "placeholder" | "deployed";
+            path: string;
+            customDomainUrl: string | undefined;
+            url: string | undefined;
+            edge: boolean | undefined;
+            server: string;
+            secrets: string[];
+        };
+        type: "SolidStartSite";
+    };
 }

package/constructs/SolidStartSite.js

@@ -58,4 +58,10 @@ export class SolidStartSite extends SsrSite {
             },
         });
     }
+    getConstructMetadata() {
+        return {
+            type: "SolidStartSite",
+            ...this.getConstructMetadataBase(),
+        };
+    }
 }

package/constructs/SsrSite.d.ts

@@ -12,7 +12,6 @@ import { Size } from "./util/size.js";
 import { Duration } from "./util/duration.js";
 import { Permissions } from "./util/permission.js";
 import { FunctionBindingProps } from "./util/functionBinding.js";
-type SsrSiteType = "NextjsSite" | "RemixSite" | "AstroSite" | "SolidStartSite" | "SvelteKitSite";
 export type SsrBuildConfig = {
     typesPath: string;
     serverBuildOutputFile: string;
@@ -209,7 +208,7 @@ type SsrSiteNormalizedProps = SsrSiteProps & {
  * });
  * ```
  */
-export declare class SsrSite extends Construct implements SSTConstruct {
+export declare abstract class SsrSite extends Construct implements SSTConstruct {
     readonly id: string;
     protected props: SsrSiteNormalizedProps;
     private doNotDeploy;
@@ -254,17 +253,18 @@ export declare class SsrSite extends Construct implements SSTConstruct {
      */
     attachPermissions(permissions: Permissions): void;
     /** @internal */
-    getConstructMetadata(): {
-        type: SsrSiteType;
+    protected getConstructMetadataBase(): {
         data: {
             mode: "placeholder" | "deployed";
             path: string;
             customDomainUrl: string | undefined;
+            url: string | undefined;
             edge: boolean | undefined;
             server: string;
             secrets: string[];
         };
     };
+    abstract getConstructMetadata(): ReturnType<SSTConstruct["getConstructMetadata"]>;
     /** @internal */
     getFunctionBinding(): FunctionBindingProps;
     protected initBuildConfig(): SsrBuildConfig;
@@ -306,10 +306,10 @@ export declare class SsrSite extends Construct implements SSTConstruct {
     protected generateBuildId(): string;
 }
 export declare const useSites: () => {
-    add(name: string, type: SsrSiteType, props: SsrSiteNormalizedProps): void;
+    add(name: string, type: string, props: SsrSiteNormalizedProps): void;
     readonly all: {
         name: string;
-        type: SsrSiteType;
+        type: string;
         props: SsrSiteNormalizedProps;
     }[];
 };

package/constructs/SsrSite.js

@@ -180,15 +180,15 @@ export class SsrSite extends Construct {
         attachPermissionsToRole(server?.role, permissions);
     }
     /** @internal */
-    getConstructMetadata() {
+    getConstructMetadataBase() {
         return {
-            type: this.constructor.name,
             data: {
                 mode: this.doNotDeploy
                     ? "placeholder"
                     : "deployed",
                 path: this.props.path,
                 customDomainUrl: this.customDomainUrl,
+                url: this.url,
                 edge: this.props.edge,
                 server: (this.serverLambdaForDev ||
                     this.serverLambdaForRegional ||

package/constructs/Stack.js

@@ -202,12 +202,8 @@ export class Stack extends CDKStack {
         });
     }
     static buildSynthesizer() {
-        const config = useProject().config;
-        const customSynethesizerKeys = Object.keys(config.cdk || {}).filter((key) => key.startsWith("qualifier"));
-        if (customSynethesizerKeys.length === 0) {
-            return;
-        }
-        return new DefaultStackSynthesizer({
+        const { config } = useProject();
+        const props = {
             qualifier: config.cdk?.qualifier,
             fileAssetsBucketName: config.cdk?.fileAssetsBucketName,
             deployRoleArn: config.cdk?.deployRoleArn,
@@ -215,7 +211,11 @@ export class Stack extends CDKStack {
             imageAssetPublishingRoleArn: config.cdk?.imageAssetPublishingRoleArn,
             cloudFormationExecutionRole: config.cdk?.cloudFormationExecutionRole,
             lookupRoleArn: config.cdk?.lookupRoleArn,
-        });
+        };
+        const isEmpty = Object.values(props).every((v) => v === undefined);
+        if (isEmpty)
+            return;
+        return new DefaultStackSynthesizer(props);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static checkForPropsIsConstruct(id, props) {

package/constructs/StaticSite.js

@@ -466,6 +466,9 @@ interface ImportMeta {
             viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
             functionAssociations: [
                 {
+                    // Note: this is required in Frameworks like Astro where `index.html`
+                    //       is required in the URL path.
+                    //       https://docs.astro.build/en/guides/deploy/aws/#cloudfront-functions-setup
                     function: new CfFunction(this, "CloudFrontFunction", {
                         code: CfFunctionCode.fromInline(`
 function handler(event) {

package/constructs/SvelteKitSite.d.ts

@@ -24,4 +24,16 @@ export declare class SvelteKitSite extends SsrSite {
     protected createFunctionForRegional(): CdkFunction;
     protected createFunctionForEdge(): EdgeFunction;
     protected generateBuildId(): string;
+    getConstructMetadata(): {
+        data: {
+            mode: "placeholder" | "deployed";
+            path: string;
+            customDomainUrl: string | undefined;
+            url: string | undefined;
+            edge: boolean | undefined;
+            server: string;
+            secrets: string[];
+        };
+        type: "SvelteKitSite";
+    };
 }

package/constructs/SvelteKitSite.js

@@ -98,4 +98,10 @@ export class SvelteKitSite extends SsrSite {
         const content = fs.readFileSync(filePath).toString();
         return JSON.parse(content).version;
     }
+    getConstructMetadata() {
+        return {
+            type: "SvelteKitSite",
+            ...this.getConstructMetadataBase(),
+        };
+    }
 }

package/node/api/index.d.ts

@@ -42,6 +42,7 @@ export declare const useResponse: () => {
     cookie(input: {
         key: string;
         value: string;
+        encrypted?: string;
     } & CookieOptions): any;
     status(code: number): any;
     header(key: string, value: string): any;

package/node/api/index.js

@@ -75,6 +75,12 @@ export const useResponse = /* @__PURE__ */ Context.memo(() => {
             return result;
         },
         cookie(input) {
+            input = {
+                secure: true,
+                sameSite: "None",
+                httpOnly: true,
+                ...input,
+            };
             const value = encodeURIComponent(input.value);
             const parts = [input.key + "=" + value];
             if (input.domain)

package/node/future/auth/adapter/code.d.ts

@@ -0,0 +1,16 @@
+import { APIGatewayProxyStructuredResultV2 } from "aws-lambda";
+export declare function CodeAdapter(config: {
+    length?: number;
+    onCode: (code: string, claims: Record<string, any>) => Promise<APIGatewayProxyStructuredResultV2>;
+}): () => Promise<{
+    type: "step";
+    properties: APIGatewayProxyStructuredResultV2;
+} | {
+    type: "error";
+    properties?: undefined;
+} | {
+    type: "success";
+    properties: {
+        claims: any;
+    };
+}>;

package/node/future/auth/adapter/code.js

@@ -0,0 +1,67 @@
+import { useCookie, usePathParam, useQueryParam, useQueryParams, useResponse, } from "../../../api/index.js";
+import { randomBytes } from "crypto";
+import { decrypt, encrypt } from "../encryption.js";
+export function CodeAdapter(config) {
+    const length = config.length || 6;
+    function generate() {
+        const buffer = randomBytes(length);
+        const otp = Array.from(buffer)
+            .map((byte) => byte % 10)
+            .join("");
+        return otp;
+    }
+    return async function () {
+        const step = usePathParam("step");
+        if (step === "authorize") {
+            const code = generate();
+            const claims = useQueryParams();
+            delete claims["client_id"];
+            delete claims["redirect_uri"];
+            delete claims["response_type"];
+            delete claims["provider"];
+            useResponse().cookies({
+                sst_code: encrypt(code),
+                sst_claims: encrypt(JSON.stringify(claims)),
+            }, {
+                maxAge: 3600,
+                secure: true,
+                sameSite: "None",
+                httpOnly: true,
+            });
+            return {
+                type: "step",
+                properties: await config.onCode(code, claims),
+            };
+        }
+        if (step === "callback") {
+            const code = decrypt(useCookie("sst_code"));
+            const claims = decrypt(useCookie("sst_claims"));
+            if (!code || !claims) {
+                return {
+                    type: "error",
+                };
+            }
+            const compare = useQueryParam("code");
+            if (code !== compare) {
+                return {
+                    type: "error",
+                };
+            }
+            useResponse().cookies({
+                sst_code: "",
+                sst_claims: "",
+            }, {
+                expires: new Date(1),
+            });
+            return {
+                type: "success",
+                properties: {
+                    claims: JSON.parse(claims),
+                },
+            };
+        }
+        return {
+            type: "error",
+        };
+    };
+}

package/node/future/auth/encryption.d.ts

@@ -0,0 +1,2 @@
+export declare function encrypt(data: string): string;
+export declare function decrypt(data: string): string | undefined;

package/node/future/auth/encryption.js

@@ -0,0 +1,30 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, } from "crypto";
+import { Config } from "../../config/index.js";
+export function encrypt(data) {
+    // @ts-expect-error
+    const key = Config[process.env.AUTH_ID + "PrivateKey"];
+    const hashed = createHash("sha256").update(key).digest();
+    const iv = randomBytes(16); // Generate a random IV (Initialization Vector)
+    const cipher = createCipheriv("aes-256-cbc", hashed, iv);
+    let encrypted = cipher.update(data, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    return JSON.stringify({
+        i: iv.toString("hex"),
+        d: encrypted,
+    });
+}
+export function decrypt(data) {
+    // @ts-expect-error
+    const key = Config[process.env.AUTH_ID + "PrivateKey"];
+    const hashed = createHash("sha256").update(key).digest();
+    try {
+        const parsed = JSON.parse(data);
+        const decipher = createDecipheriv("aes-256-cbc", hashed, Buffer.from(parsed.i, "hex"));
+        let decrypted = decipher.update(parsed.d, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+    }
+    catch {
+        return;
+    }
+}

package/node/future/auth/handler.js

@@ -23,9 +23,6 @@ const onSuccessResponse = {
                     Location: "/authorize?" +
                         new URLSearchParams({
                             provider,
-                            response_type: useCookie("response_type"),
-                            client_id: useCookie("client_id"),
-                            redirect_uri: useCookie("redirect_uri"),
                         }).toString(),
                 },
             },
@@ -128,7 +125,10 @@ export function AuthHandler(input) {
                     body: "Missing provider",
                 };
             }
-            const { response_type, client_id, redirect_uri, state } = useQueryParams();
+            const { response_type, client_id, redirect_uri, state } = {
+                ...useCookies(),
+                ...useQueryParams(),
+            };
             if (!provider) {
                 return {
                     statusCode: 400,
@@ -199,13 +199,20 @@ export function AuthHandler(input) {
                     type,
                     properties,
                 });
-                useResponse().cookie({
+                useResponse()
+                    .cookie({
                     key: "sst_auth_token",
                     value: token,
                     maxAge: 10 * 365 * 24 * 60 * 60,
-                    secure: true,
-                    sameSite: "None",
-                    httpOnly: true,
+                })
+                    .cookies({
+                    provider: "",
+                    response_type: "",
+                    client_id: "",
+                    redirect_uri: "",
+                    state: "",
+                }, {
+                    expires: new Date(1),
                 });
                 const { client_id, response_type, redirect_uri, state } = {
                     ...useCookies(),

package/node/future/auth/index.d.ts

@@ -9,7 +9,9 @@ export * from "./adapter/facebook.js";
 export * from "./adapter/microsoft.js";
 export * from "./adapter/oauth.js";
 export * from "./adapter/spotify.js";
+export * from "./adapter/code.js";
 export type { Adapter } from "./adapter/adapter.js";
 export * from "./session.js";
 export * from "./handler.js";
+export * from "./encryption.js";
 export { Issuer } from "openid-client";