effortless-aws 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -47,21 +47,26 @@ type EffortlessConfig = {
     handlers?: string | string[];
     /**
      * Default settings applied to all handlers unless overridden.
+     *
+     * All Lambdas run on ARM64 (Graviton2) architecture — ~20% cheaper than x86_64
+     * with better price-performance for most workloads.
      */
     defaults?: {
         /**
-         * Lambda memory in MB.
+         * Lambda memory in MB. AWS allocates proportional CPU —
+         * 1769 MB gives one full vCPU.
          * @default 256
          */
         memory?: number;
         /**
          * Lambda timeout as a human-readable string.
+         * AWS maximum is 15 minutes.
          * @example "30 seconds", "5 minutes"
          */
         timeout?: string;
         /**
-         * Lambda runtime.
-         * @default "nodejs22.x"
+         * Node.js Lambda runtime version.
+         * @default "nodejs24.x"
          */
         runtime?: string;
     };
@@ -83,9 +88,6 @@ type EffortlessConfig = {
  */
 declare const defineConfig: (config: EffortlessConfig) => EffortlessConfig;
 
-type AwsService = "dynamodb" | "s3" | "sqs" | "sns" | "ses" | "ssm" | "lambda" | "events" | "secretsmanager" | "cognito-idp" | "logs";
-type Permission = `${AwsService}:${string}` | (string & {});
-
 /**
  * Query parameters for TableClient.query()
  */
@@ -143,57 +145,9 @@ type TableClient<T = Record<string, unknown>> = {
     tableName: string;
 };
 
-type AnyParamRef = ParamRef<any>;
-/**
- * Reference to an SSM Parameter Store parameter.
- *
- * @typeParam T - The resolved type after optional transform (default: string)
- */
-type ParamRef<T = string> = {
-    readonly __brand: "effortless-param";
-    readonly key: string;
-    readonly transform?: (raw: string) => T;
-};
-/**
- * Maps a params declaration to resolved value types.
- *
- * @typeParam P - Record of param names to ParamRef instances
- */
-type ResolveParams<P> = {
-    [K in keyof P]: P[K] extends ParamRef<infer T> ? T : never;
-};
-/**
- * Declare an SSM Parameter Store parameter.
- *
- * The key is combined with project and stage at deploy time to form the full
- * SSM path: `/${project}/${stage}/${key}`.
- *
- * @param key - Parameter key (e.g., "database-url")
- * @param transform - Optional function to transform the raw string value
- * @returns A ParamRef used by the deployment and runtime systems
- *
- * @example Simple string parameter
- * ```typescript
- * params: {
- *   dbUrl: param("database-url"),
- * }
- * ```
- *
- * @example With transform (e.g., TOML parsing)
- * ```typescript
- * import TOML from "smol-toml";
- *
- * params: {
- *   config: param("app-config", TOML.parse),
- * }
- * ```
- */
-declare function param(key: string): ParamRef<string>;
-declare function param<T>(key: string, transform: (raw: string) => T): ParamRef<T>;
-
-type AnyTableHandler$1 = TableHandler<any, any, any, any, any, any>;
+type AnyTableHandler$2 = TableHandler<any, any, any, any, any, any>;
 /** Maps a deps declaration to resolved runtime client types */
-type ResolveDeps$1<D> = {
+type ResolveDeps$2<D> = {
     [K in keyof D]: D[K] extends TableHandler<infer T, any, any, any, any> ? TableClient<T> : never;
 };
 /** DynamoDB attribute types for keys */
@@ -212,9 +166,7 @@ type StreamView = "NEW_AND_OLD_IMAGES" | "NEW_IMAGE" | "OLD_IMAGE" | "KEYS_ONLY"
 /**
  * Configuration options extracted from DefineTableOptions (without onRecord/context)
  */
-type TableConfig = {
-    /** Table/handler name. Defaults to export name if not specified */
-    name?: string;
+type TableConfig = LambdaWithPermissions & {
     /** Partition key definition */
     pk: TableKey;
     /** Sort key definition (optional) */
@@ -231,14 +183,6 @@ type TableConfig = {
     batchWindow?: number;
     /** Where to start reading the stream (default: "LATEST") */
     startingPosition?: "LATEST" | "TRIM_HORIZON";
-    /** Lambda memory in MB (default: 256) */
-    memory?: number;
-    /** Lambda timeout in seconds (default: 30) */
-    timeout?: number;
-    /** Additional IAM permissions for the Lambda */
-    permissions?: Permission[];
-    /** Enable observability logging to platform table (default: true) */
-    observe?: boolean;
 };
 /**
  * DynamoDB stream record passed to onRecord callback
@@ -275,7 +219,7 @@ type FailedRecord<T = Record<string, unknown>> = {
  * Without params: `() => C | Promise<C>`
  * With params: `(args: { params: ResolveParams<P> }) => C | Promise<C>`
  */
-type ContextFactory$1<C, P> = [P] extends [undefined] ? () => C | Promise<C> : (args: {
+type ContextFactory$2<C, P> = [P] extends [undefined] ? () => C | Promise<C> : (args: {
     params: ResolveParams<P & {}>;
 }) => C | Promise<C>;
 /**
@@ -287,7 +231,7 @@ type TableRecordFn<T = Record<string, unknown>, C = undefined, R = void, D = und
 } & ([C] extends [undefined] ? {} : {
     ctx: C;
 }) & ([D] extends [undefined] ? {} : {
-    deps: ResolveDeps$1<D>;
+    deps: ResolveDeps$2<D>;
 }) & ([P] extends [undefined] ? {} : {
     params: ResolveParams<P>;
 }) & ([S] extends [undefined] ? {} : {
@@ -303,7 +247,7 @@ type TableBatchCompleteFn<T = Record<string, unknown>, C = undefined, R = void,
 } & ([C] extends [undefined] ? {} : {
     ctx: C;
 }) & ([D] extends [undefined] ? {} : {
-    deps: ResolveDeps$1<D>;
+    deps: ResolveDeps$2<D>;
 }) & ([P] extends [undefined] ? {} : {
     params: ResolveParams<P>;
 }) & ([S] extends [undefined] ? {} : {
@@ -318,7 +262,7 @@ type TableBatchFn<T = Record<string, unknown>, C = undefined, D = undefined, P =
 } & ([C] extends [undefined] ? {} : {
     ctx: C;
 }) & ([D] extends [undefined] ? {} : {
-    deps: ResolveDeps$1<D>;
+    deps: ResolveDeps$2<D>;
 }) & ([P] extends [undefined] ? {} : {
     params: ResolveParams<P>;
 }) & ([S] extends [undefined] ? {} : {
@@ -343,7 +287,7 @@ type DefineTableBase<T = Record<string, unknown>, C = undefined, D = undefined,
      * When params are declared, receives resolved params as argument.
      * Supports both sync and async return values.
      */
-    context?: ContextFactory$1<C, P>;
+    context?: ContextFactory$2<C, P>;
     /**
      * Dependencies on other handlers (tables, queues, etc.).
      * Typed clients are injected into the handler via the `deps` argument.
@@ -379,7 +323,7 @@ type DefineTableResourceOnly<T = Record<string, unknown>, C = undefined, D = und
     onBatch?: never;
     onBatchComplete?: never;
 };
-type DefineTableOptions<T = Record<string, unknown>, C = undefined, R = void, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined> = DefineTableWithOnRecord<T, C, R, D, P, S> | DefineTableWithOnBatch<T, C, D, P, S> | DefineTableResourceOnly<T, C, D, P, S>;
+type DefineTableOptions<T = Record<string, unknown>, C = undefined, R = void, D extends Record<string, AnyTableHandler$2> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined> = DefineTableWithOnRecord<T, C, R, D, P, S> | DefineTableWithOnBatch<T, C, D, P, S> | DefineTableResourceOnly<T, C, D, P, S>;
 /**
  * Internal handler object created by defineTable
  * @internal
@@ -428,7 +372,389 @@ type TableHandler<T = Record<string, unknown>, C = undefined, R = void, D = unde
  * });
  * ```
  */
-declare const defineTable: <T = Record<string, unknown>, C = undefined, R = void, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineTableOptions<T, C, R, D, P, S>) => TableHandler<T, C, R, D, P, S>;
+declare const defineTable: <T = Record<string, unknown>, C = undefined, R = void, D extends Record<string, AnyTableHandler$2> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineTableOptions<T, C, R, D, P, S>) => TableHandler<T, C, R, D, P, S>;
+
+/**
+ * Configuration for a Lambda-served static site (API Gateway + Lambda)
+ */
+type AppConfig = LambdaConfig & {
+    /** Base URL path the site is served under (e.g., "/app") */
+    path?: string;
+    /** Directory containing the static site files, relative to project root */
+    dir: string;
+    /** Default file for directory requests (default: "index.html") */
+    index?: string;
+    /** SPA mode: serve index.html for all paths that don't match a file (default: false) */
+    spa?: boolean;
+    /** Shell command to run before deploy to generate site content (e.g., "npx astro build") */
+    build?: string;
+};
+/**
+ * Internal handler object created by defineApp
+ * @internal
+ */
+type AppHandler = {
+    readonly __brand: "effortless-app";
+    readonly config: AppConfig;
+};
+/**
+ * Deploy a static site via Lambda + API Gateway.
+ * Files are bundled into the Lambda ZIP and served with auto-detected content types.
+ *
+ * For CDN-backed sites (S3 + CloudFront), use {@link defineStaticSite} instead.
+ *
+ * @param options - Site configuration: path, directory, optional SPA mode
+ * @returns Handler object used by the deployment system
+ *
+ * @example Basic static site
+ * ```typescript
+ * export const app = defineApp({
+ *   path: "/app",
+ *   dir: "src/webapp",
+ * });
+ * ```
+ */
+declare const defineApp: (options: AppConfig) => AppHandler;
+
+/**
+ * Configuration for a static site handler (S3 + CloudFront)
+ */
+type StaticSiteConfig = {
+    /** Handler name. Defaults to export name if not specified */
+    name?: string;
+    /** Directory containing the static site files, relative to project root */
+    dir: string;
+    /** Default file for directory requests (default: "index.html") */
+    index?: string;
+    /** SPA mode: serve index.html for all paths that don't match a file (default: false) */
+    spa?: boolean;
+    /** Shell command to run before deploy to generate site content (e.g., "npx astro build") */
+    build?: string;
+};
+/**
+ * Internal handler object created by defineStaticSite
+ * @internal
+ */
+type StaticSiteHandler = {
+    readonly __brand: "effortless-static-site";
+    readonly config: StaticSiteConfig;
+};
+/**
+ * Deploy a static site via S3 + CloudFront CDN.
+ *
+ * @param options - Static site configuration: directory, optional SPA mode, build command
+ * @returns Handler object used by the deployment system
+ *
+ * @example Documentation site
+ * ```typescript
+ * export const docs = defineStaticSite({
+ *   dir: "dist",
+ *   build: "npx astro build",
+ * });
+ * ```
+ *
+ * @example SPA with client-side routing
+ * ```typescript
+ * export const app = defineStaticSite({
+ *   dir: "dist",
+ *   spa: true,
+ *   build: "npm run build",
+ * });
+ * ```
+ */
+declare const defineStaticSite: (options: StaticSiteConfig) => StaticSiteHandler;
+
+type AnyTableHandler$1 = TableHandler<any, any, any, any, any, any>;
+/** Maps a deps declaration to resolved runtime client types */
+type ResolveDeps$1<D> = {
+    [K in keyof D]: D[K] extends TableHandler<infer T, any, any, any, any> ? TableClient<T> : never;
+};
+/**
+ * Parsed SQS FIFO message passed to the handler callbacks.
+ *
+ * @typeParam T - Type of the decoded message body (from schema function)
+ */
+type FifoQueueMessage<T = unknown> = {
+    /** Unique message identifier */
+    messageId: string;
+    /** Receipt handle for acknowledgement */
+    receiptHandle: string;
+    /** Parsed message body (JSON-decoded, then optionally schema-validated) */
+    body: T;
+    /** Raw unparsed message body string */
+    rawBody: string;
+    /** Message group ID (FIFO ordering key) */
+    messageGroupId: string;
+    /** Message deduplication ID */
+    messageDeduplicationId?: string;
+    /** SQS message attributes */
+    messageAttributes: Record<string, {
+        dataType?: string;
+        stringValue?: string;
+    }>;
+    /** Approximate first receive timestamp */
+    approximateFirstReceiveTimestamp?: string;
+    /** Approximate receive count */
+    approximateReceiveCount?: string;
+    /** Sent timestamp */
+    sentTimestamp?: string;
+};
+/**
+ * Configuration options for a FIFO queue handler
+ */
+type FifoQueueConfig = LambdaWithPermissions & {
+    /** Number of messages per Lambda invocation (1-10 for FIFO, default: 10) */
+    batchSize?: number;
+    /** Maximum time in seconds to gather messages before invoking (0-300, default: 0) */
+    batchWindow?: number;
+    /** Visibility timeout in seconds (default: max of timeout or 30) */
+    visibilityTimeout?: number;
+    /** Message retention period in seconds (60-1209600, default: 345600 = 4 days) */
+    retentionPeriod?: number;
+    /** Enable content-based deduplication (default: true) */
+    contentBasedDeduplication?: boolean;
+};
+/**
+ * Context factory type — conditional on whether params are declared.
+ * Without params: `() => C | Promise<C>`
+ * With params: `(args: { params: ResolveParams<P> }) => C | Promise<C>`
+ */
+type ContextFactory$1<C, P> = [P] extends [undefined] ? () => C | Promise<C> : (args: {
+    params: ResolveParams<P & {}>;
+}) => C | Promise<C>;
+/**
+ * Per-message handler function.
+ * Called once per message in the batch. Failures are reported individually.
+ */
+type FifoQueueMessageFn<T = unknown, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = (args: {
+    message: FifoQueueMessage<T>;
+} & ([C] extends [undefined] ? {} : {
+    ctx: C;
+}) & ([D] extends [undefined] ? {} : {
+    deps: ResolveDeps$1<D>;
+}) & ([P] extends [undefined] ? {} : {
+    params: ResolveParams<P>;
+}) & ([S] extends [undefined] ? {} : {
+    readStatic: (path: string) => string;
+})) => Promise<void>;
+/**
+ * Batch handler function.
+ * Called once with all messages in the batch.
+ */
+type FifoQueueBatchFn<T = unknown, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = (args: {
+    messages: FifoQueueMessage<T>[];
+} & ([C] extends [undefined] ? {} : {
+    ctx: C;
+}) & ([D] extends [undefined] ? {} : {
+    deps: ResolveDeps$1<D>;
+}) & ([P] extends [undefined] ? {} : {
+    params: ResolveParams<P>;
+}) & ([S] extends [undefined] ? {} : {
+    readStatic: (path: string) => string;
+})) => Promise<void>;
+/** Base options shared by all defineFifoQueue variants */
+type DefineFifoQueueBase<T = unknown, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = FifoQueueConfig & {
+    /**
+     * Decode/validate function for the message body.
+     * Called with the JSON-parsed body; should return typed data or throw on validation failure.
+     */
+    schema?: (input: unknown) => T;
+    /**
+     * Error handler called when onMessage or onBatch throws.
+     * If not provided, defaults to `console.error`.
+     */
+    onError?: (error: unknown) => void;
+    /**
+     * Factory function to create context/dependencies for the handler.
+     * Called once on cold start, result is cached and reused across invocations.
+     * When params are declared, receives resolved params as argument.
+     */
+    context?: ContextFactory$1<C, P>;
+    /**
+     * Dependencies on other handlers (tables, queues, etc.).
+     * Typed clients are injected into the handler via the `deps` argument.
+     */
+    deps?: D;
+    /**
+     * SSM Parameter Store parameters.
+     * Declare with `param()` helper. Values are fetched and cached at cold start.
+     */
+    params?: P;
+    /**
+     * Static file glob patterns to bundle into the Lambda ZIP.
+     * Files are accessible at runtime via the `readStatic` callback argument.
+     */
+    static?: S;
+};
+/** Per-message processing */
+type DefineFifoQueueWithOnMessage<T = unknown, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = DefineFifoQueueBase<T, C, D, P, S> & {
+    onMessage: FifoQueueMessageFn<T, C, D, P, S>;
+    onBatch?: never;
+};
+/** Batch processing: all messages at once */
+type DefineFifoQueueWithOnBatch<T = unknown, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = DefineFifoQueueBase<T, C, D, P, S> & {
+    onBatch: FifoQueueBatchFn<T, C, D, P, S>;
+    onMessage?: never;
+};
+type DefineFifoQueueOptions<T = unknown, C = undefined, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined> = DefineFifoQueueWithOnMessage<T, C, D, P, S> | DefineFifoQueueWithOnBatch<T, C, D, P, S>;
+/**
+ * Internal handler object created by defineFifoQueue
+ * @internal
+ */
+type FifoQueueHandler<T = unknown, C = undefined, D = undefined, P = undefined, S extends string[] | undefined = undefined> = {
+    readonly __brand: "effortless-fifo-queue";
+    readonly config: FifoQueueConfig;
+    readonly schema?: (input: unknown) => T;
+    readonly onError?: (error: unknown) => void;
+    readonly context?: (...args: any[]) => C | Promise<C>;
+    readonly deps?: D;
+    readonly params?: P;
+    readonly static?: string[];
+    readonly onMessage?: FifoQueueMessageFn<T, C, D, P, S>;
+    readonly onBatch?: FifoQueueBatchFn<T, C, D, P, S>;
+};
+/**
+ * Define a FIFO SQS queue with a Lambda message handler
+ *
+ * Creates:
+ * - SQS FIFO queue (with `.fifo` suffix)
+ * - Lambda function triggered by the queue
+ * - Event source mapping with partial batch failure support
+ *
+ * @example Per-message processing
+ * ```typescript
+ * type OrderEvent = { orderId: string; action: string };
+ *
+ * export const orderQueue = defineFifoQueue<OrderEvent>({
+ *   onMessage: async ({ message }) => {
+ *     console.log("Processing order:", message.body.orderId);
+ *   }
+ * });
+ * ```
+ *
+ * @example Batch processing with schema
+ * ```typescript
+ * export const notifications = defineFifoQueue({
+ *   schema: (input) => NotificationSchema.parse(input),
+ *   batchSize: 5,
+ *   onBatch: async ({ messages }) => {
+ *     await sendAll(messages.map(m => m.body));
+ *   }
+ * });
+ * ```
+ */
+declare const defineFifoQueue: <T = unknown, C = undefined, D extends Record<string, AnyTableHandler$1> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineFifoQueueOptions<T, C, D, P, S>) => FifoQueueHandler<T, C, D, P, S>;
+
+type AwsService = "dynamodb" | "s3" | "sqs" | "sns" | "ses" | "ssm" | "lambda" | "events" | "secretsmanager" | "cognito-idp" | "logs";
+type Permission = `${AwsService}:${string}` | (string & {});
+/** Logging verbosity level for Lambda handlers */
+type LogLevel = "error" | "info" | "debug";
+/**
+ * Common Lambda configuration shared by all handler types.
+ */
+type LambdaConfig = {
+    /** Handler name. Defaults to export name if not specified */
+    name?: string;
+    /** Lambda memory in MB (default: 256) */
+    memory?: number;
+    /** Lambda timeout in seconds (default: 30) */
+    timeout?: number;
+    /** Logging verbosity: "error" (errors only), "info" (+ execution summary), "debug" (+ input/output). Default: "info" */
+    logLevel?: LogLevel;
+};
+/**
+ * Lambda configuration with additional IAM permissions.
+ * Used by handler types that support custom permissions (http, table, fifo-queue).
+ */
+type LambdaWithPermissions = LambdaConfig & {
+    /** Additional IAM permissions for the Lambda */
+    permissions?: Permission[];
+};
+type AnyParamRef = ParamRef<any>;
+/**
+ * Reference to an SSM Parameter Store parameter.
+ *
+ * @typeParam T - The resolved type after optional transform (default: string)
+ */
+type ParamRef<T = string> = {
+    readonly __brand: "effortless-param";
+    readonly key: string;
+    readonly transform?: (raw: string) => T;
+};
+/**
+ * Maps a params declaration to resolved value types.
+ *
+ * @typeParam P - Record of param names to ParamRef instances
+ */
+type ResolveParams<P> = {
+    [K in keyof P]: P[K] extends ParamRef<infer T> ? T : never;
+};
+/**
+ * Declare an SSM Parameter Store parameter.
+ *
+ * The key is combined with project and stage at deploy time to form the full
+ * SSM path: `/${project}/${stage}/${key}`.
+ *
+ * @param key - Parameter key (e.g., "database-url")
+ * @param transform - Optional function to transform the raw string value
+ * @returns A ParamRef used by the deployment and runtime systems
+ *
+ * @example Simple string parameter
+ * ```typescript
+ * params: {
+ *   dbUrl: param("database-url"),
+ * }
+ * ```
+ *
+ * @example With transform (e.g., TOML parsing)
+ * ```typescript
+ * import TOML from "smol-toml";
+ *
+ * params: {
+ *   config: param("app-config", TOML.parse),
+ * }
+ * ```
+ */
+declare function param(key: string): ParamRef<string>;
+declare function param<T>(key: string, transform: (raw: string) => T): ParamRef<T>;
+/**
+ * Type-only schema helper for handlers.
+ *
+ * Use this instead of explicit generic parameters like `defineTable<Order>(...)`.
+ * It enables TypeScript to infer all generic types from the options object,
+ * avoiding the partial-inference problem where specifying one generic
+ * forces all others to their defaults.
+ *
+ * At runtime this is a no-op identity function — it simply returns the input unchanged.
+ * The type narrowing happens entirely at the TypeScript level.
+ *
+ * @example Resource-only table
+ * ```typescript
+ * type User = { id: string; email: string };
+ *
+ * // Before (breaks inference for context, deps, params):
+ * export const users = defineTable<User>({ pk: { name: "id", type: "string" } });
+ *
+ * // After (all generics inferred correctly):
+ * export const users = defineTable({
+ *   pk: { name: "id", type: "string" },
+ *   schema: typed<User>(),
+ * });
+ * ```
+ *
+ * @example Table with stream handler
+ * ```typescript
+ * export const orders = defineTable({
+ *   pk: { name: "id", type: "string" },
+ *   schema: typed<Order>(),
+ *   context: async () => ({ db: createClient() }),
+ *   onRecord: async ({ record, ctx }) => {
+ *     // record.new is Order, ctx is { db: Client } — all inferred
+ *   },
+ * });
+ * ```
+ */
+declare function typed<T>(): (input: unknown) => T;
 
 type AnyTableHandler = TableHandler<any, any, any, any, any, any>;
 /** Maps a deps declaration to resolved runtime client types */
@@ -484,21 +810,11 @@ type HttpResponse = {
 /**
  * Configuration options extracted from DefineHttpOptions (without onRequest callback)
  */
-type HttpConfig = {
-    /** Handler name. Defaults to export name if not specified */
-    name?: string;
+type HttpConfig = LambdaWithPermissions & {
     /** HTTP method for the route */
     method: HttpMethod;
     /** Route path (e.g., "/api/users", "/api/users/{id}") */
     path: string;
-    /** Lambda memory in MB (default: 256) */
-    memory?: number;
-    /** Lambda timeout in seconds (default: 30) */
-    timeout?: number;
-    /** Additional IAM permissions for the Lambda */
-    permissions?: Permission[];
-    /** Enable observability logging to platform table (default: true) */
-    observe?: boolean;
 };
 /**
  * Handler function type for HTTP endpoints
@@ -639,141 +955,4 @@ type HttpHandler<T = undefined, C = undefined, D = undefined, P = undefined, S e
  */
 declare const defineHttp: <T = undefined, C = undefined, D extends Record<string, AnyTableHandler> | undefined = undefined, P extends Record<string, AnyParamRef> | undefined = undefined, S extends string[] | undefined = undefined>(options: DefineHttpOptions<T, C, D, P, S>) => HttpHandler<T, C, D, P, S>;
 
-/**
- * Configuration for a Lambda-served static site (API Gateway + Lambda)
- */
-type AppConfig = {
-    /** Handler name. Defaults to export name if not specified */
-    name?: string;
-    /** Base URL path the site is served under (e.g., "/app") */
-    path?: string;
-    /** Directory containing the static site files, relative to project root */
-    dir: string;
-    /** Default file for directory requests (default: "index.html") */
-    index?: string;
-    /** SPA mode: serve index.html for all paths that don't match a file (default: false) */
-    spa?: boolean;
-    /** Shell command to run before deploy to generate site content (e.g., "npx astro build") */
-    build?: string;
-    /** Lambda memory in MB (default: 256) */
-    memory?: number;
-    /** Lambda timeout in seconds (default: 5) */
-    timeout?: number;
-    /** Enable observability logging to platform table (default: false) */
-    observe?: boolean;
-};
-/**
- * Internal handler object created by defineApp
- * @internal
- */
-type AppHandler = {
-    readonly __brand: "effortless-app";
-    readonly config: AppConfig;
-};
-/**
- * Deploy a static site via Lambda + API Gateway.
- * Files are bundled into the Lambda ZIP and served with auto-detected content types.
- *
- * For CDN-backed sites (S3 + CloudFront), use {@link defineStaticSite} instead.
- *
- * @param options - Site configuration: path, directory, optional SPA mode
- * @returns Handler object used by the deployment system
- *
- * @example Basic static site
- * ```typescript
- * export const app = defineApp({
- *   path: "/app",
- *   dir: "src/webapp",
- * });
- * ```
- */
-declare const defineApp: (options: AppConfig) => AppHandler;
-
-/**
- * Configuration for a static site handler (S3 + CloudFront)
- */
-type StaticSiteConfig = {
-    /** Handler name. Defaults to export name if not specified */
-    name?: string;
-    /** Directory containing the static site files, relative to project root */
-    dir: string;
-    /** Default file for directory requests (default: "index.html") */
-    index?: string;
-    /** SPA mode: serve index.html for all paths that don't match a file (default: false) */
-    spa?: boolean;
-    /** Shell command to run before deploy to generate site content (e.g., "npx astro build") */
-    build?: string;
-};
-/**
- * Internal handler object created by defineStaticSite
- * @internal
- */
-type StaticSiteHandler = {
-    readonly __brand: "effortless-static-site";
-    readonly config: StaticSiteConfig;
-};
-/**
- * Deploy a static site via S3 + CloudFront CDN.
- *
- * @param options - Static site configuration: directory, optional SPA mode, build command
- * @returns Handler object used by the deployment system
- *
- * @example Documentation site
- * ```typescript
- * export const docs = defineStaticSite({
- *   dir: "dist",
- *   build: "npx astro build",
- * });
- * ```
- *
- * @example SPA with client-side routing
- * ```typescript
- * export const app = defineStaticSite({
- *   dir: "dist",
- *   spa: true,
- *   build: "npm run build",
- * });
- * ```
- */
-declare const defineStaticSite: (options: StaticSiteConfig) => StaticSiteHandler;
-
-type BasePlatformEntity = {
-    pk: string;
-    sk: string;
-    type: string;
-    ttl?: number;
-};
-type ExecutionEntry = {
-    id: string;
-    ts: string;
-    ms: number;
-    in: unknown;
-    out?: unknown;
-};
-type ErrorEntry = {
-    id: string;
-    ts: string;
-    ms: number;
-    in: unknown;
-    err: string;
-};
-type ExecutionLogEntity = BasePlatformEntity & {
-    type: "execution-log";
-    handlerName: string;
-    handlerType: "http" | "table";
-    executions: ExecutionEntry[];
-    errors: ErrorEntry[];
-};
-type PlatformEntity = ExecutionLogEntity;
-
-type PlatformClient = {
-    appendExecution(handlerName: string, handlerType: "http" | "table" | "app", entry: ExecutionEntry): Promise<void>;
-    appendError(handlerName: string, handlerType: "http" | "table" | "app", entry: ErrorEntry): Promise<void>;
-    get<T extends PlatformEntity>(pk: string, sk: string): Promise<T | undefined>;
-    query<T extends PlatformEntity>(pk: string, skPrefix?: string): Promise<T[]>;
-    put(entity: PlatformEntity): Promise<void>;
-    tableName: string;
-};
-declare const createPlatformClient: () => PlatformClient | undefined;
-
-export { type AppConfig, type AppHandler, type BasePlatformEntity, type ContentType, type DefineHttpOptions, type DefineTableOptions, type EffortlessConfig, type ErrorEntry, type ExecutionEntry, type ExecutionLogEntity, type FailedRecord, type HttpConfig, type HttpHandler, type HttpHandlerFn, type HttpMethod, type HttpRequest, type HttpResponse, type KeyType, type ParamRef, type PlatformClient, type PlatformEntity, type QueryParams, type ResolveDeps, type ResolveParams, type StaticSiteConfig, type StaticSiteHandler, type StreamView, type TableBatchCompleteFn, type TableBatchFn, type TableClient, type TableConfig, type TableHandler, type TableKey, type TableRecord, type TableRecordFn, createPlatformClient, defineApp, defineConfig, defineHttp, defineStaticSite, defineTable, param };
+export { type AppConfig, type AppHandler, type ContentType, type DefineFifoQueueOptions, type DefineHttpOptions, type DefineTableOptions, type EffortlessConfig, type FailedRecord, type FifoQueueBatchFn, type FifoQueueConfig, type FifoQueueHandler, type FifoQueueMessage, type FifoQueueMessageFn, type HttpConfig, type HttpHandler, type HttpHandlerFn, type HttpMethod, type HttpRequest, type HttpResponse, type KeyType, type LambdaConfig, type LambdaWithPermissions, type LogLevel, type ParamRef, type QueryParams, type ResolveDeps, type ResolveParams, type StaticSiteConfig, type StaticSiteHandler, type StreamView, type TableBatchCompleteFn, type TableBatchFn, type TableClient, type TableConfig, type TableHandler, type TableKey, type TableRecord, type TableRecordFn, defineApp, defineConfig, defineFifoQueue, defineHttp, defineStaticSite, defineTable, param, typed };