@remotion/serverless 4.0.244 → 4.0.246

package/dist/handlers/still.js

@@ -0,0 +1,335 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stillHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const no_react_1 = require("remotion/no-react");
+const version_1 = require("remotion/version");
+const cleanup_serialized_input_props_1 = require("../cleanup-serialized-input-props");
+const compress_props_1 = require("../compress-props");
+const constants_1 = require("../constants");
+const expected_out_name_1 = require("../expected-out-name");
+const format_costs_info_1 = require("../format-costs-info");
+const get_or_create_bucket_1 = require("../get-or-create-bucket");
+const on_downloads_helpers_1 = require("../on-downloads-helpers");
+const overall_render_progress_1 = require("../overall-render-progress");
+const validate_composition_1 = require("../validate-composition");
+const validate_download_behavior_1 = require("../validate-download-behavior");
+const validate_outname_1 = require("../validate-outname");
+const validate_privacy_1 = require("../validate-privacy");
+const write_error_to_storage_1 = require("../write-error-to-storage");
+const check_version_mismatch_1 = require("./check-version-mismatch");
+const innerStillHandler = async ({ params, expectedBucketOwner, renderId, onStream, timeoutInMilliseconds, providerSpecifics, insideFunctionSpecifics, }, cleanup) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (params.type !== constants_1.ServerlessRoutines.still) {
+        throw new TypeError('Expected still type');
+    }
+    (0, check_version_mismatch_1.checkVersionMismatch)({
+        apiName: 'renderStillOnLambda()',
+        insideFunctionSpecifics,
+        params,
+    });
+    (0, validate_download_behavior_1.validateDownloadBehavior)(params.downloadBehavior);
+    (0, validate_privacy_1.validatePrivacy)(params.privacy, true);
+    (0, validate_outname_1.validateOutname)({
+        outName: params.outName,
+        codec: null,
+        audioCodecSetting: null,
+        separateAudioTo: null,
+    });
+    const start = Date.now();
+    const browserInstancePromise = insideFunctionSpecifics.getBrowserInstance({
+        logLevel: params.logLevel,
+        indent: false,
+        chromiumOptions: params.chromiumOptions,
+        providerSpecifics,
+        insideFunctionSpecifics,
+    });
+    const bucketNamePromise = (_a = params.bucketName) !== null && _a !== void 0 ? _a : (0, get_or_create_bucket_1.internalGetOrCreateBucket)({
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        enableFolderExpiry: null,
+        customCredentials: null,
+        providerSpecifics,
+        forcePathStyle: params.forcePathStyle,
+        skipPutAcl: false,
+    }).then((b) => b.bucketName);
+    const outputDir = renderer_1.RenderInternals.tmpDir('remotion-render-');
+    const outputPath = node_path_1.default.join(outputDir, 'output');
+    const region = providerSpecifics.getCurrentRegionInFunction();
+    const bucketName = await bucketNamePromise;
+    const serializedInputPropsWithCustomSchema = await (0, compress_props_1.decompressInputProps)({
+        bucketName,
+        expectedBucketOwner,
+        region,
+        serialized: params.inputProps,
+        propsType: 'input-props',
+        providerSpecifics,
+        forcePathStyle: params.forcePathStyle,
+    });
+    const serveUrl = providerSpecifics.convertToServeUrl({
+        urlOrId: params.serveUrl,
+        region,
+        bucketName,
+    });
+    const { server, cleanupServer } = await renderer_1.RenderInternals.makeOrReuseServer(undefined, {
+        concurrency: 1,
+        indent: false,
+        port: null,
+        remotionRoot: process.cwd(),
+        logLevel: params.logLevel,
+        webpackConfigOrServeUrl: serveUrl,
+        offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+        binariesDirectory: null,
+        forceIPv4: false,
+    }, {
+        onDownload: () => undefined,
+    });
+    cleanup.push(() => cleanupServer(true));
+    const browserInstance = await browserInstancePromise;
+    const composition = await (0, validate_composition_1.validateComposition)({
+        serveUrl,
+        browserInstance: browserInstance.instance,
+        composition: params.composition,
+        serializedInputPropsWithCustomSchema,
+        envVariables: (_b = params.envVariables) !== null && _b !== void 0 ? _b : {},
+        chromiumOptions: params.chromiumOptions,
+        timeoutInMilliseconds: params.timeoutInMilliseconds,
+        port: null,
+        forceHeight: params.forceHeight,
+        forceWidth: params.forceWidth,
+        logLevel: params.logLevel,
+        server,
+        offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+        onBrowserDownload: () => {
+            throw new Error('Should not download a browser in Lambda');
+        },
+        onServeUrlVisited: () => undefined,
+        providerSpecifics,
+    });
+    const renderMetadata = {
+        startedDate: Date.now(),
+        codec: null,
+        compositionId: params.composition,
+        estimatedTotalLambdaInvokations: 1,
+        estimatedRenderLambdaInvokations: 1,
+        siteId: serveUrl,
+        totalChunks: 1,
+        type: 'still',
+        imageFormat: params.imageFormat,
+        inputProps: params.inputProps,
+        lambdaVersion: version_1.VERSION,
+        framesPerLambda: 1,
+        memorySizeInMb: insideFunctionSpecifics.getCurrentMemorySizeInMb(),
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        renderId,
+        outName: (_c = params.outName) !== null && _c !== void 0 ? _c : undefined,
+        privacy: params.privacy,
+        audioCodec: null,
+        deleteAfter: params.deleteAfter,
+        numberOfGifLoops: null,
+        downloadBehavior: params.downloadBehavior,
+        audioBitrate: null,
+        metadata: null,
+        functionName: insideFunctionSpecifics.getCurrentFunctionName(),
+        dimensions: {
+            height: composition.height * ((_d = params.scale) !== null && _d !== void 0 ? _d : 1),
+            width: composition.width * ((_e = params.scale) !== null && _e !== void 0 ? _e : 1),
+        },
+    };
+    const still = (0, overall_render_progress_1.makeInitialOverallRenderProgress)(timeoutInMilliseconds);
+    still.renderMetadata = renderMetadata;
+    await providerSpecifics.writeFile({
+        bucketName,
+        key: (0, constants_1.overallProgressKey)(renderId),
+        body: JSON.stringify(still),
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        privacy: 'private',
+        expectedBucketOwner,
+        downloadBehavior: null,
+        customCredentials: null,
+        forcePathStyle: params.forcePathStyle,
+    });
+    const onBrowserDownload = () => {
+        throw new Error('Should not download a browser in Lambda');
+    };
+    const receivedArtifact = [];
+    const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, bucketName, (0, expected_out_name_1.getCredentialsFromOutName)(params.outName));
+    const onArtifact = (artifact) => {
+        if (receivedArtifact.find((a) => a.filename === artifact.filename)) {
+            return { alreadyExisted: true };
+        }
+        const storageKey = (0, constants_1.artifactName)(renderMetadata.renderId, artifact.filename);
+        receivedArtifact.push(providerSpecifics.makeArtifactWithDetails({
+            storageKey,
+            artifact,
+            region,
+            renderBucketName,
+        }));
+        const startTime = Date.now();
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Writing artifact ' + artifact.filename + ' to S3');
+        providerSpecifics
+            .writeFile({
+            bucketName: renderBucketName,
+            key: storageKey,
+            body: artifact.content,
+            region,
+            privacy: params.privacy,
+            expectedBucketOwner,
+            downloadBehavior: params.downloadBehavior,
+            customCredentials,
+            forcePathStyle: params.forcePathStyle,
+        })
+            .then(() => {
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, `Wrote artifact to S3 in ${Date.now() - startTime}ms`);
+        })
+            .catch((err) => {
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to write artifact to S3', err);
+        });
+        return { alreadyExisted: false };
+    };
+    await renderer_1.RenderInternals.internalRenderStill({
+        composition,
+        output: outputPath,
+        serveUrl,
+        envVariables: (_f = params.envVariables) !== null && _f !== void 0 ? _f : {},
+        frame: renderer_1.RenderInternals.convertToPositiveFrameIndex({
+            frame: params.frame,
+            durationInFrames: composition.durationInFrames,
+        }),
+        imageFormat: params.imageFormat,
+        serializedInputPropsWithCustomSchema,
+        overwrite: false,
+        puppeteerInstance: browserInstance.instance,
+        jpegQuality: (_g = params.jpegQuality) !== null && _g !== void 0 ? _g : renderer_1.RenderInternals.DEFAULT_JPEG_QUALITY,
+        chromiumOptions: params.chromiumOptions,
+        scale: params.scale,
+        timeoutInMilliseconds: params.timeoutInMilliseconds,
+        browserExecutable: providerSpecifics.getChromiumPath(),
+        cancelSignal: null,
+        indent: false,
+        onBrowserLog: null,
+        onDownload: (0, on_downloads_helpers_1.onDownloadsHelper)(params.logLevel),
+        port: null,
+        server,
+        logLevel: params.logLevel,
+        serializedResolvedPropsWithCustomSchema: no_react_1.NoReactInternals.serializeJSONWithDate({
+            indent: undefined,
+            staticBase: null,
+            data: composition.props,
+        }).serializedString,
+        offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+        binariesDirectory: null,
+        onBrowserDownload,
+        onArtifact,
+    });
+    const { size } = await node_fs_1.default.promises.stat(outputPath);
+    await providerSpecifics.writeFile({
+        bucketName: renderBucketName,
+        key,
+        privacy: params.privacy,
+        body: node_fs_1.default.createReadStream(outputPath),
+        expectedBucketOwner,
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        downloadBehavior: params.downloadBehavior,
+        customCredentials,
+        forcePathStyle: params.forcePathStyle,
+    });
+    await Promise.all([
+        node_fs_1.default.promises.rm(outputPath, { recursive: true }),
+        (0, cleanup_serialized_input_props_1.cleanupSerializedInputProps)({
+            region: providerSpecifics.getCurrentRegionInFunction(),
+            serialized: params.inputProps,
+            providerSpecifics,
+            forcePathStyle: params.forcePathStyle,
+        }),
+        server.closeServer(true),
+    ]);
+    const estimatedPrice = providerSpecifics.estimatePrice({
+        durationInMilliseconds: Date.now() - start + 100,
+        memorySizeInMb: insideFunctionSpecifics.getCurrentMemorySizeInMb(),
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        lambdasInvoked: 1,
+        diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
+    });
+    const { key: outKey, url } = providerSpecifics.getOutputUrl({
+        renderMetadata,
+        bucketName,
+        customCredentials,
+        currentRegion: providerSpecifics.getCurrentRegionInFunction(),
+    });
+    const payload = {
+        type: 'success',
+        output: url,
+        size,
+        sizeInBytes: size,
+        bucketName,
+        estimatedPrice: (0, format_costs_info_1.formatCostsInfo)(estimatedPrice),
+        renderId,
+        outKey,
+        receivedArtifacts: receivedArtifact,
+    };
+    onStream({
+        type: 'still-rendered',
+        payload,
+    });
+    await server.closeServer(true);
+};
+const stillHandler = async (options) => {
+    const { params } = options;
+    const cleanUpFn = [];
+    if (params.type !== constants_1.ServerlessRoutines.still) {
+        throw new Error('Params must be renderer');
+    }
+    try {
+        await innerStillHandler(options, cleanUpFn);
+        return { type: 'success' };
+    }
+    catch (err) {
+        // If this error is encountered, we can just retry as it
+        // is a very rare error to occur
+        const isBrowserError = options.providerSpecifics.isFlakyError(err);
+        const willRetry = isBrowserError || params.maxRetries > 0;
+        renderer_1.RenderInternals.Log.error({
+            indent: false,
+            logLevel: params.logLevel,
+        }, 'Got error:', err.stack, `Will retry = ${willRetry}`);
+        if (params.streamed) {
+            await options.onStream({
+                type: 'error-occurred',
+                payload: {
+                    error: err.stack,
+                    shouldRetry: willRetry,
+                    errorInfo: {
+                        name: err.name,
+                        message: err.message,
+                        stack: err.stack,
+                        chunk: null,
+                        frame: params.frame,
+                        type: 'renderer',
+                        isFatal: false,
+                        tmpDir: (0, write_error_to_storage_1.getTmpDirStateIfENoSp)(err.stack, options.providerSpecifics),
+                        attempt: params.attempt,
+                        totalAttempts: 1 + params.maxRetries,
+                        willRetry,
+                    },
+                },
+            });
+        }
+        return {
+            type: 'error',
+            message: err.message,
+            stack: err.stack,
+        };
+    }
+    finally {
+        options.insideFunctionSpecifics.forgetBrowserEventLoop(options.params.type === constants_1.ServerlessRoutines.still
+            ? options.params.logLevel
+            : 'error');
+        cleanUpFn.forEach((c) => c());
+    }
+};
+exports.stillHandler = stillHandler;

package/dist/index.d.ts

@@ -1,14 +1,30 @@
-export { compositionsHandler } from './compositions';
+export { PostRenderData, ServerlessRoutines } from './constants';
+export { estimatePriceFromMetadata as estimatePriceFromBucket } from './estimate-price-from-bucket';
 export { getCredentialsFromOutName } from './expected-out-name';
-export { forgetBrowserEventLoop, getBrowserInstance, } from './get-browser-instance';
+export { formatCostsInfo } from './format-costs-info';
+export { forgetBrowserEventLoopImplementation, getBrowserInstanceImplementation, } from './get-browser-instance';
+export { compositionsHandler } from './handlers/compositions';
+export { launchHandler } from './handlers/launch';
+export { progressHandler } from './handlers/progress';
+export { RequestContext, rendererHandler } from './handlers/renderer';
+export { startHandler } from './handlers/start';
+export { stillHandler } from './handlers/still';
 export { infoHandler } from './info';
-export { MakeArtifactWithDetails, ProviderSpecifics, WriteFileInput, } from './provider-implementation';
+export { innerHandler } from './inner-routine';
+export { inspectErrors } from './inspect-error';
+export { WebhookClient, WebhookErrorPayload, WebhookPayload, WebhookSuccessPayload, WebhookTimeoutPayload, invokeWebhook, } from './invoke-webhook';
+export { setCurrentRequestId, stopLeakDetection } from './leak-detection';
+export { OVERHEAD_TIME_PER_LAMBDA, getMostExpensiveChunks, } from './most-expensive-chunks';
+export { OverallProgressHelper, OverallRenderProgress, makeInitialOverallRenderProgress, makeOverallRenderProgress, } from './overall-render-progress';
+export * from './provider-implementation';
+export type { CleanupInfo, GenericRenderProgress } from './render-progress';
+export { OrError, ServerlessReturnValues } from './return-values';
 export { deserializeArtifact, serializeArtifact } from './serialize-artifact';
-export { CloudProvider, CostsInfo, ReceivedArtifact, RenderStillLambdaResponsePayload, } from './still';
 export { ResponseStream } from './streaming/response-stream';
 export { ResponseStreamWriter, streamWriter } from './streaming/stream-writer';
 export { type OnMessage, type OnStream, type StreamingMessage, type StreamingPayload, } from './streaming/streaming';
+export * from './types';
 export { validateComposition } from './validate-composition';
 export { validateOutname } from './validate-outname';
 export { MAX_WEBHOOK_CUSTOM_DATA_SIZE, validateWebhook, } from './validate-webhook';
-export { EnhancedErrorInfo, LambdaErrorInfo, getTmpDirStateIfENoSp, } from './write-lambda-error';
+export { EnhancedErrorInfo, FunctionErrorInfo as LambdaErrorInfo, getTmpDirStateIfENoSp, } from './write-error-to-storage';

package/dist/index.js

@@ -1,15 +1,61 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTmpDirStateIfENoSp = exports.validateWebhook = exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE = exports.validateOutname = exports.validateComposition = exports.streamWriter = exports.ResponseStream = exports.serializeArtifact = exports.deserializeArtifact = exports.infoHandler = exports.getBrowserInstance = exports.forgetBrowserEventLoop = exports.getCredentialsFromOutName = exports.compositionsHandler = void 0;
-var compositions_1 = require("./compositions");
-Object.defineProperty(exports, "compositionsHandler", { enumerable: true, get: function () { return compositions_1.compositionsHandler; } });
+exports.getTmpDirStateIfENoSp = exports.validateWebhook = exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE = exports.validateOutname = exports.validateComposition = exports.streamWriter = exports.ResponseStream = exports.serializeArtifact = exports.deserializeArtifact = exports.makeOverallRenderProgress = exports.makeInitialOverallRenderProgress = exports.getMostExpensiveChunks = exports.OVERHEAD_TIME_PER_LAMBDA = exports.stopLeakDetection = exports.setCurrentRequestId = exports.invokeWebhook = exports.inspectErrors = exports.innerHandler = exports.infoHandler = exports.stillHandler = exports.startHandler = exports.rendererHandler = exports.progressHandler = exports.launchHandler = exports.compositionsHandler = exports.getBrowserInstanceImplementation = exports.forgetBrowserEventLoopImplementation = exports.formatCostsInfo = exports.getCredentialsFromOutName = exports.estimatePriceFromBucket = exports.ServerlessRoutines = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "ServerlessRoutines", { enumerable: true, get: function () { return constants_1.ServerlessRoutines; } });
+var estimate_price_from_bucket_1 = require("./estimate-price-from-bucket");
+Object.defineProperty(exports, "estimatePriceFromBucket", { enumerable: true, get: function () { return estimate_price_from_bucket_1.estimatePriceFromMetadata; } });
 var expected_out_name_1 = require("./expected-out-name");
 Object.defineProperty(exports, "getCredentialsFromOutName", { enumerable: true, get: function () { return expected_out_name_1.getCredentialsFromOutName; } });
+var format_costs_info_1 = require("./format-costs-info");
+Object.defineProperty(exports, "formatCostsInfo", { enumerable: true, get: function () { return format_costs_info_1.formatCostsInfo; } });
 var get_browser_instance_1 = require("./get-browser-instance");
-Object.defineProperty(exports, "forgetBrowserEventLoop", { enumerable: true, get: function () { return get_browser_instance_1.forgetBrowserEventLoop; } });
-Object.defineProperty(exports, "getBrowserInstance", { enumerable: true, get: function () { return get_browser_instance_1.getBrowserInstance; } });
+Object.defineProperty(exports, "forgetBrowserEventLoopImplementation", { enumerable: true, get: function () { return get_browser_instance_1.forgetBrowserEventLoopImplementation; } });
+Object.defineProperty(exports, "getBrowserInstanceImplementation", { enumerable: true, get: function () { return get_browser_instance_1.getBrowserInstanceImplementation; } });
+var compositions_1 = require("./handlers/compositions");
+Object.defineProperty(exports, "compositionsHandler", { enumerable: true, get: function () { return compositions_1.compositionsHandler; } });
+var launch_1 = require("./handlers/launch");
+Object.defineProperty(exports, "launchHandler", { enumerable: true, get: function () { return launch_1.launchHandler; } });
+var progress_1 = require("./handlers/progress");
+Object.defineProperty(exports, "progressHandler", { enumerable: true, get: function () { return progress_1.progressHandler; } });
+var renderer_1 = require("./handlers/renderer");
+Object.defineProperty(exports, "rendererHandler", { enumerable: true, get: function () { return renderer_1.rendererHandler; } });
+var start_1 = require("./handlers/start");
+Object.defineProperty(exports, "startHandler", { enumerable: true, get: function () { return start_1.startHandler; } });
+var still_1 = require("./handlers/still");
+Object.defineProperty(exports, "stillHandler", { enumerable: true, get: function () { return still_1.stillHandler; } });
 var info_1 = require("./info");
 Object.defineProperty(exports, "infoHandler", { enumerable: true, get: function () { return info_1.infoHandler; } });
+var inner_routine_1 = require("./inner-routine");
+Object.defineProperty(exports, "innerHandler", { enumerable: true, get: function () { return inner_routine_1.innerHandler; } });
+var inspect_error_1 = require("./inspect-error");
+Object.defineProperty(exports, "inspectErrors", { enumerable: true, get: function () { return inspect_error_1.inspectErrors; } });
+var invoke_webhook_1 = require("./invoke-webhook");
+Object.defineProperty(exports, "invokeWebhook", { enumerable: true, get: function () { return invoke_webhook_1.invokeWebhook; } });
+var leak_detection_1 = require("./leak-detection");
+Object.defineProperty(exports, "setCurrentRequestId", { enumerable: true, get: function () { return leak_detection_1.setCurrentRequestId; } });
+Object.defineProperty(exports, "stopLeakDetection", { enumerable: true, get: function () { return leak_detection_1.stopLeakDetection; } });
+var most_expensive_chunks_1 = require("./most-expensive-chunks");
+Object.defineProperty(exports, "OVERHEAD_TIME_PER_LAMBDA", { enumerable: true, get: function () { return most_expensive_chunks_1.OVERHEAD_TIME_PER_LAMBDA; } });
+Object.defineProperty(exports, "getMostExpensiveChunks", { enumerable: true, get: function () { return most_expensive_chunks_1.getMostExpensiveChunks; } });
+var overall_render_progress_1 = require("./overall-render-progress");
+Object.defineProperty(exports, "makeInitialOverallRenderProgress", { enumerable: true, get: function () { return overall_render_progress_1.makeInitialOverallRenderProgress; } });
+Object.defineProperty(exports, "makeOverallRenderProgress", { enumerable: true, get: function () { return overall_render_progress_1.makeOverallRenderProgress; } });
+__exportStar(require("./provider-implementation"), exports);
 var serialize_artifact_1 = require("./serialize-artifact");
 Object.defineProperty(exports, "deserializeArtifact", { enumerable: true, get: function () { return serialize_artifact_1.deserializeArtifact; } });
 Object.defineProperty(exports, "serializeArtifact", { enumerable: true, get: function () { return serialize_artifact_1.serializeArtifact; } });
@@ -17,6 +63,7 @@ var response_stream_1 = require("./streaming/response-stream");
 Object.defineProperty(exports, "ResponseStream", { enumerable: true, get: function () { return response_stream_1.ResponseStream; } });
 var stream_writer_1 = require("./streaming/stream-writer");
 Object.defineProperty(exports, "streamWriter", { enumerable: true, get: function () { return stream_writer_1.streamWriter; } });
+__exportStar(require("./types"), exports);
 var validate_composition_1 = require("./validate-composition");
 Object.defineProperty(exports, "validateComposition", { enumerable: true, get: function () { return validate_composition_1.validateComposition; } });
 var validate_outname_1 = require("./validate-outname");
@@ -24,5 +71,5 @@ Object.defineProperty(exports, "validateOutname", { enumerable: true, get: funct
 var validate_webhook_1 = require("./validate-webhook");
 Object.defineProperty(exports, "MAX_WEBHOOK_CUSTOM_DATA_SIZE", { enumerable: true, get: function () { return validate_webhook_1.MAX_WEBHOOK_CUSTOM_DATA_SIZE; } });
 Object.defineProperty(exports, "validateWebhook", { enumerable: true, get: function () { return validate_webhook_1.validateWebhook; } });
-var write_lambda_error_1 = require("./write-lambda-error");
-Object.defineProperty(exports, "getTmpDirStateIfENoSp", { enumerable: true, get: function () { return write_lambda_error_1.getTmpDirStateIfENoSp; } });
+var write_error_to_storage_1 = require("./write-error-to-storage");
+Object.defineProperty(exports, "getTmpDirStateIfENoSp", { enumerable: true, get: function () { return write_error_to_storage_1.getTmpDirStateIfENoSp; } });

package/dist/info.d.ts

@@ -1,5 +1,5 @@
 import type { ServerlessPayload } from './constants';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 export declare const infoHandler: <Provider extends CloudProvider>(serverlessParams: ServerlessPayload<Provider>) => Promise<{
     version: string;
     type: "success";

package/dist/inner-routine.d.ts

@@ -0,0 +1,22 @@
+import type { ServerlessPayload } from './constants';
+import type { RequestContext } from './handlers/renderer';
+import type { WebhookClient } from './invoke-webhook';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from './provider-implementation';
+import type { ResponseStreamWriter } from './streaming/stream-writer';
+import type { CloudProvider } from './types';
+export declare const innerHandler: <Provider extends CloudProvider>({ params, responseWriter, context, providerSpecifics, insideFunctionSpecifics, webhookClient, }: {
+    params: ServerlessPayload<Provider>;
+    responseWriter: ResponseStreamWriter;
+    context: RequestContext;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+    webhookClient: WebhookClient;
+}) => Promise<void>;
+export declare const innerRoutine: <Provider extends CloudProvider>({ params, responseWriter, context, providerSpecifics, insideFunctionSpecifics, webhookClient, }: {
+    params: ServerlessPayload<Provider>;
+    responseWriter: ResponseStreamWriter;
+    context: RequestContext;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+    webhookClient: WebhookClient;
+}) => Promise<void>;