@hyperframes/aws-lambda 0.8.177 → 0.8.179

package/dist/s3PlanV2Publisher.d.ts

@@ -20,6 +20,7 @@ export declare class S3PlanV2ArtifactPublisher implements PlanV2ArtifactPublishe
     readonly manifestUri: string;
     constructor(options: Readonly<S3PlanV2ArtifactPublisherOptions>);
     putBlob(blob: Readonly<PlanV2PublishBlob>): Promise<void>;
+    referenceStoredBlob(blob: Readonly<Omit<PlanV2PublishBlob, "sourcePath">>): Promise<void>;
     commitManifest(manifestBytes: string): Promise<void>;
     abort(): Promise<void>;
 }

package/dist/s3Transport.d.ts

@@ -30,6 +30,11 @@ export declare function formatS3Uri(loc: S3Location): string;
 export declare function downloadS3ObjectToFile(client: S3Client, uri: string, destPath: string): Promise<void>;
 /** Download and verify an immutable plan-v2 artifact before materialization. */
 export declare function downloadS3ObjectToFileVerified(client: S3Client, uri: string, destPath: string, expectedSha256: string): Promise<void>;
+/**
+ * Pre-sign a GET for a plan-v2 artifact, after S3 attests the object's stored
+ * SHA-256 and size are the ones the manifest pins.
+ */
+export declare function presignVerifiedS3GetUrl(client: S3Client, uri: string, expectedSha256: string, expectedSize: number, expiresInSeconds: number): Promise<string>;
 /**
  * Upload a local file's contents to an S3 URI using a streaming
  * `PutObjectCommand`. PutObject's 5 GB cap comfortably exceeds the
@@ -44,14 +49,22 @@ export declare function uploadFileToS3(client: S3Client, localPath: string, uri:
  * and a conflicting one is never overwritten, since a chunk may already be reading that plan.
  */
 export declare function uploadContentAddressedFileToS3(client: S3Client, localPath: string, uri: string, expectedSha256: string, contentType?: string): Promise<"uploaded" | "reused">;
+export declare function mapConcurrent<T>(values: readonly T[], concurrency: number, fn: (value: T) => Promise<void>): Promise<void>;
 export declare function sha256File(path: string): Promise<string>;
+/** Put a file into the shared content store once; reusing an aging object restarts its expiry. */
+export declare function putContentStoreFile(client: S3Client, localPath: string, bucket: string, sha256: string): Promise<"uploaded" | "reused">;
+/** Confirm an object the caller never uploaded is in the content store, restarting an aging one. */
+export declare function ensureContentStoreObject(client: S3Client, bucket: string, sha256: string, sizeBytes: number): Promise<void>;
+export declare function presignS3GetUrl(client: S3Client, uri: string, expiresInSeconds: number): Promise<string>;
+export declare function s3ObjectExists(client: S3Client, uri: string): Promise<boolean>;
+export declare function isS3NotFound(error: unknown): boolean;
 /**
  * Pack a directory into a `.tar.gz` at `destTarball`. Uses the `tar` npm
  * package (pure JS over `node:zlib`) rather than spawning a system tar
  * binary — the AWS Lambda Node 22 base image ships a minimal set of
  * userland tools and does NOT include `tar` in `/usr/bin`.
  */
-export declare function tarDirectory(sourceDir: string, destTarball: string): Promise<void>;
+export declare function tarDirectory(sourceDir: string, destTarball: string, files?: string[]): Promise<void>;
 /**
  * Extract a `.tar.gz` produced by {@link tarDirectory} into `destDir`.
  * The directory is created (or cleared) before extraction so a retried

package/dist/sdk/deploySite.d.ts

@@ -1,15 +1,14 @@
 /**
- * `deploySite` — upload a project directory to S3 once per content hash
- * and return a reusable handle.
+ * `deploySite` — upload a project directory to S3 and return a reusable handle.
  *
  * `renderToLambda` calls this implicitly when no `siteHandle` is passed,
- * but exposing it as a standalone verb lets adopters bundle a project
- * ahead of time and reuse the handle across many renders without
- * re-tarring the project tree on every call.
+ * but exposing it as a standalone verb lets adopters upload a project
+ * ahead of time and reuse the handle across many renders.
  *
- * The handle is **content-addressed**: `siteId` is derived from a SHA-256
- * over the project files. Two `deploySite` calls on an unchanged tree
- * produce the same `siteId` and `HeadObject`-short-circuit the upload.
+ * Every file goes into the bucket's shared content store under its SHA-256,
+ * once: a file any earlier site or render already stored is skipped. The
+ * site itself is a small `sites/<siteId>/files.json` listing path → hash,
+ * where `siteId` is derived from a SHA-256 over the project files.
  */
 import { S3Client } from "@aws-sdk/client-s3";
 /** Options for {@link deploySite}. */
@@ -35,20 +34,21 @@ export interface SiteHandle {
     siteId: string;
     /** Bucket the site landed in. Surfaced separately so callers don't have to re-parse `projectS3Uri`. */
     bucketName: string;
-    /** Full `s3://bucket/sites/<siteId>/project.tar.gz` URI; pass through to `renderToLambda`. */
+    /** Full `s3://bucket/sites/<siteId>/files.json` URI; pass through to `renderToLambda`. */
     projectS3Uri: string;
-    /** Tarball size in bytes; useful for "did we actually skip the upload?" assertions. */
+    /** Total size of the project's files in bytes. */
     bytes: number;
-    /** ISO timestamp of the most recent upload OR the existing object the short-circuit found. */
+    /** ISO timestamp of this `deploySite` call. */
     uploadedAt: string;
-    /** `false` if the object already existed and we skipped the PUT. */
+    /** `false` if every file and the site manifest were already in the bucket. */
     uploaded: boolean;
 }
+/** Handle for a site an earlier {@link deploySite} uploaded; `bytes` and `uploadedAt` are unknown. */
+export declare function siteHandleFromId(bucketName: string, siteId: string): SiteHandle;
 /**
- * Upload `projectDir` to `s3://bucketName/sites/<siteId>/project.tar.gz`.
- *
- * Short-circuits when an object with the same key already exists in the
- * bucket — `siteId` derives from the project's content hash, so the same
- * bytes produce the same key, and re-uploading would be redundant.
+ * Before a render reuses `site`, re-store any file the content store expired, from `projectDir`.
+ * Returns the handle to render: a site uploaded before site manifests resolves to its tarball.
  */
+export declare function ensureSiteStored(site: SiteHandle, s3: S3Client, projectDir?: string): Promise<SiteHandle>;
+/** Upload `projectDir`'s files to the content store and write the site manifest. */
 export declare function deploySite(opts: DeploySiteOptions): Promise<SiteHandle>;

package/dist/sdk/index.d.ts

@@ -7,10 +7,11 @@
  * `puppeteer-core` into the module graph. The SDK files here are
  * AWS-SDK only — safe to load in any Node environment.
  */
-export { deploySite, type DeploySiteOptions, type SiteHandle } from "./deploySite.js";
-export { renderToLambda, type RenderHandle, type RenderToLambdaOptions } from "./renderToLambda.js";
+export { deploySite, type DeploySiteOptions, type SiteHandle, siteHandleFromId, } from "./deploySite.js";
+export { assertStackReadsSites, renderToLambda, type RenderHandle, type RenderToLambdaOptions, } from "./renderToLambda.js";
 export { getRenderProgress, type GetRenderProgressOptions, type RenderError, type RenderProgress, type RenderStatus, } from "./getRenderProgress.js";
 export { type BilledLambdaInvocation, computeRenderCost, type RenderCost, } from "./costAccounting.js";
 export { InvalidConfigError, MAX_STEP_FUNCTIONS_INPUT_BYTES, validateDistributedRenderConfig, validateStepFunctionsInputSize, validateVariablesPayload, } from "./validateConfig.js";
+export { type PrebuiltHandler, prebuiltHandler } from "./prebuiltHandler.js";
 export type { SerializableDistributedRenderConfig } from "../events.js";
 export type { DistributedFormat } from "../formatExtension.js";