@karmaniverous/smoz 0.1.2

package/dist/cjs/serverless-plugin.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var node_child_process = require('node:child_process');
+var path = require('node:path');
+
+/* REQUIREMENTS ADDRESSED
+ * - Provide a lightweight Serverless Framework plugin that ensures registers are fresh
+ *   by running `smoz register` before package/deploy.
+ * - Keep it simple: spawn Node to run the packaged CJS CLI, inherit stdio, and fail fast.
+ *
+ * Notes:
+ * - This file is bundled to dist/cjs/serverless-plugin.js and exported via the "./serverless-plugin" subpath.
+ * - Serverless v4 loads CJS plugins via `require`; exporting a default class allows
+ *   rollup to wrap it for CJS while preserving the ESM entry for completeness.
+ */
+const runRegister = () => {
+    // Resolve the packaged CLI entry relative to the compiled CJS plugin:
+    // dist/cjs/serverless-plugin.js -> ../cli/index.cjs
+    const cliPath = path.resolve(__dirname, '../cli/index.cjs');
+    const res = node_child_process.spawnSync(process.execPath, [cliPath, 'register'], {
+        stdio: 'inherit',
+        shell: false,
+    });
+    const code = typeof res.status === 'number' ? String(res.status) : 'unknown';
+    if (res.status !== 0)
+        throw new Error(`smoz register failed (exit code ${code})`);
+};
+// Minimal Serverless v4 plugin: register hooks that run before package/deploy.
+class SmozRegisterPlugin {
+    hooks;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(_serverless, _options) {
+        this.hooks = {
+            // Package lifecycle
+            'before:package:initialize': runRegister,
+            // Deploy lifecycles where functions/artifacts can be (re)built
+            'before:deploy:function:initialize': runRegister,
+            'before:deploy:deploy': runRegister,
+        };
+    }
+}
+
+module.exports = SmozRegisterPlugin;

package/dist/index.d.ts

@@ -0,0 +1,422 @@
+import { AWS } from '@serverless/typescript';
+import { z, ZodObject, ZodRawShape } from 'zod';
+import { ZodOpenApiPathsObject, ZodOpenApiPathItemObject } from 'zod-openapi';
+import { buildStageArtifacts } from '@/src/core/buildStageArtifacts';
+import { EnvSchemaNode as EnvSchemaNode$1 } from '@/src/core/defineAppConfig';
+import { serverlessConfigSchema, AppServerlessConfig } from '@/src/core/serverlessConfig';
+import { ZodObj } from '@/src/core/types';
+import { AppHttpConfig as AppHttpConfig$1 } from '@/src/http/middleware/httpStackCustomization';
+import { MethodKey as MethodKey$1, FunctionConfig } from '@/src/types/FunctionConfig';
+import { HttpContext as HttpContext$1 } from '@/src/types/HttpContext';
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2, ALBEvent, SQSEvent, SNSEvent, S3Event, DynamoDBStreamEvent, KinesisStreamEvent, EventBridgeEvent, CloudWatchLogsEvent, SESEvent, CloudFrontRequestEvent, FirehoseTransformationEvent, CognitoUserPoolTriggerEvent, Context } from 'aws-lambda';
+import { stagesFactory } from '@/src/serverless/stagesFactory';
+import { SecurityContextHttpEventMap as SecurityContextHttpEventMap$1 } from '@/src/types/SecurityContextHttpEventMap';
+import { BaseEventTypeMap } from '@/src/core/baseEventTypeMapSchema';
+import { EnvAttached } from '@/src/core/defineFunctionConfig';
+import { Handler as Handler$1 } from '@/src/types/Handler';
+import { MiddlewareObj } from '@middy/core';
+import httpContentNegotiation from '@middy/http-content-negotiation';
+import httpCors from '@middy/http-cors';
+import httpErrorHandler from '@middy/http-error-handler';
+import httpHeaderNormalizer from '@middy/http-header-normalizer';
+import httpJsonBodyParser from '@middy/http-json-body-parser';
+import { HttpTransform, PhasedArrays } from '@/src/http/middleware/transformUtils';
+import { ConsoleLogger as ConsoleLogger$1 } from '@/src/types/Loggable';
+import { DeepOverride } from '@/src/types/DeepOverride';
+import { PropFromUnion } from '@/src/types/PropFromUnion';
+
+interface AppInit<GlobalParamsSchema extends ZodObj, StageParamsSchema extends ZodObj, EventTypeMapSchema extends ZodObj> {
+    appRootAbs: string;
+    globalParamsSchema: GlobalParamsSchema;
+    stageParamsSchema: StageParamsSchema;
+    eventTypeMapSchema?: EventTypeMapSchema;
+    /** Accept raw serverless config; App will parse it internally. */
+    serverless: z.input<typeof serverlessConfigSchema>;
+    global: {
+        params: z.infer<GlobalParamsSchema>;
+        envKeys: readonly (keyof z.infer<GlobalParamsSchema>)[];
+    };
+    stage: {
+        /** Accept raw stage param objects; App will parse with (global.partial + stage) */
+        params: Record<string, Record<string, unknown>>;
+        envKeys: readonly (keyof z.infer<StageParamsSchema>)[];
+    };
+    /**
+     * HTTP tokens to treat as HTTP at runtime (widenable).
+     * Defaults to ['rest', 'http'].
+     */
+    httpEventTypeTokens?: readonly (keyof z.infer<EventTypeMapSchema>)[];
+    /**
+     * Optional app-level HTTP middleware customization (defaults & profiles).
+     */
+    http?: AppHttpConfig$1;
+    /** Optional defaults applied to every function (merged per registration). */
+    functionDefaults?: {
+        fnEnvKeys?: readonly string[];
+    };
+}
+/**
+ * Application class. *
+ * @typeParam GlobalParamsSchema - Zod object schema for global parameters
+ * @typeParam StageParamsSchema  - Zod object schema for per‑stage parameters
+ * @typeParam EventTypeMapSchema - Zod object schema mapping event tokens to runtime types
+ */ declare class App<GlobalParamsSchema extends ZodObj, StageParamsSchema extends ZodObj, EventTypeMapSchema extends ZodObj> {
+    /** Helper alias for stage artifacts type */
+    private static readonly _stageArtifactsType;
+    readonly appRootAbs: string;
+    readonly globalParamsSchema: GlobalParamsSchema;
+    readonly stageParamsSchema: StageParamsSchema;
+    readonly eventTypeMapSchema: EventTypeMapSchema;
+    readonly serverless: AppServerlessConfig;
+    readonly global: EnvSchemaNode$1<GlobalParamsSchema>;
+    readonly stage: EnvSchemaNode$1<StageParamsSchema>;
+    readonly stages: ReturnType<typeof buildStageArtifacts>['stages'];
+    readonly environment: ReturnType<typeof buildStageArtifacts>['environment'];
+    readonly buildFnEnv: ReturnType<typeof buildStageArtifacts>['buildFnEnv'];
+    readonly http: AppHttpConfig$1;
+    readonly httpEventTypeTokens: readonly string[];
+    private readonly registry;
+    private constructor(); /**
+     * Ergonomic constructor for schema‑first inference.
+     *
+     * @param init - initialization object (schemas, serverless defaults, params/envKeys)
+     * @returns a new App instance
+     */
+    static create<GlobalParamsSchema extends ZodObj, StageParamsSchema extends ZodObj, EventTypeMapSchema extends ZodObj>(init: AppInit<GlobalParamsSchema, StageParamsSchema, EventTypeMapSchema>): App<GlobalParamsSchema, StageParamsSchema, EventTypeMapSchema>;
+    /**
+     * Register a function (HTTP or non‑HTTP).
+     *
+     * @typeParam EventType      - A key from your eventTypeMapSchema (e.g., 'rest' | 'http' | 'sqs' | 'step')
+     * @typeParam EventSchema    - Optional Zod schema validated BEFORE the handler (refines event shape)
+     * @typeParam ResponseSchema - Optional Zod schema validated AFTER the handler (refines response shape)
+     * @param options - per‑function configuration (method/basePath/httpContexts for HTTP; serverless extras for non‑HTTP)
+     * @returns a per‑function API: { handler(business), openapi(baseOperation), serverless(extras) }
+     */
+    defineFunction<EventType extends Extract<keyof z.infer<EventTypeMapSchema>, string>, EventSchema extends z.ZodType | undefined, ResponseSchema extends z.ZodType | undefined>(options: {
+        functionName?: string;
+        eventType: EventType;
+        method?: MethodKey$1;
+        basePath?: string;
+        httpContexts?: readonly HttpContext$1[];
+        contentType?: string;
+        eventSchema?: EventSchema;
+        responseSchema?: ResponseSchema;
+        fnEnvKeys?: readonly (keyof (z.infer<GlobalParamsSchema> & z.infer<StageParamsSchema>))[];
+        callerModuleUrl: string;
+        endpointsRootAbs: string;
+    }): any;
+    /**
+     * Aggregate Serverless function definitions across the registry.
+     *
+     * @returns An AWS['functions'] object suitable for serverless.ts
+     */
+    buildAllServerlessFunctions(): AWS['functions'];
+    /**
+     * Aggregate OpenAPI path items across the registry.
+     *
+     * @returns ZodOpenApiPathsObject to be embedded in a full OpenAPI document
+     */
+    buildAllOpenApiPaths(): ZodOpenApiPathsObject;
+}
+
+/**
+ * baseEventTypeMapSchema
+ * - Schema-first companion to BaseEventTypeMap.
+ * - Ensures z.infer<typeof baseEventTypeMapSchema> === BaseEventTypeMap.
+ *
+ * @remarks
+ * Consumers typically extend this schema when creating an App to add
+ * project‑local event tokens (e.g., 'step').
+ * Only tokens listed in the app’s `httpEventTypeTokens` are treated as HTTP at runtime.
+ */
+
+declare const baseEventTypeMapSchema: z.ZodObject<{
+    rest: z.ZodCustom<APIGatewayProxyEvent, APIGatewayProxyEvent>;
+    http: z.ZodCustom<APIGatewayProxyEventV2, APIGatewayProxyEventV2>;
+    alb: z.ZodCustom<ALBEvent, ALBEvent>;
+    sqs: z.ZodCustom<SQSEvent, SQSEvent>;
+    sns: z.ZodCustom<SNSEvent, SNSEvent>;
+    s3: z.ZodCustom<S3Event, S3Event>;
+    dynamodb: z.ZodCustom<DynamoDBStreamEvent, DynamoDBStreamEvent>;
+    kinesis: z.ZodCustom<KinesisStreamEvent, KinesisStreamEvent>;
+    eventbridge: z.ZodCustom<EventBridgeEvent<string, unknown>, EventBridgeEvent<string, unknown>>;
+    'cloudwatch-logs': z.ZodCustom<CloudWatchLogsEvent, CloudWatchLogsEvent>;
+    ses: z.ZodCustom<SESEvent, SESEvent>;
+    cloudfront: z.ZodCustom<CloudFrontRequestEvent, CloudFrontRequestEvent>;
+    firehose: z.ZodCustom<FirehoseTransformationEvent, FirehoseTransformationEvent>;
+    'cognito-userpool': z.ZodCustom<CognitoUserPoolTriggerEvent, CognitoUserPoolTriggerEvent>;
+}, z.core.$strip>;
+
+/** Base: envKeys tied to a Zod schema’s inferred keys. */
+/**
+ * Bind a list of environment keys to a schema’s inferred key space.
+ *
+ * @typeParam Schema - Zod object schema
+ * @remarks Used to express “these keys are allowed to be exposed from this schema”.
+ */
+interface EnvKeysNode<Schema extends ZodObject<ZodRawShape>> {
+    envKeys: readonly (keyof z.infer<Schema>)[];
+}
+/** For wrapper input: schema + envKeys. */
+interface EnvSchemaNode<Schema extends ZodObject<ZodRawShape>> extends EnvKeysNode<Schema> {
+    paramsSchema: Schema;
+}
+/** Wrapper input: no glue; both global and stage sides. */
+/**
+ * Environment configuration bounds for an application.
+ *
+ * @typeParam GlobalParamsSchema - Global params schema
+ * @typeParam StageParamsSchema  - Per‑stage params schema
+ */
+interface GlobalEnvConfig<GlobalParamsSchema extends ZodObject<ZodRawShape>, StageParamsSchema extends ZodObject<ZodRawShape>> {
+    global: EnvSchemaNode<GlobalParamsSchema>;
+    stage: EnvSchemaNode<StageParamsSchema>;
+}
+/** Authoring input — global: concrete params + envKeys. */
+/**
+ * Concrete global configuration for authoring (params + env exposure).
+ *
+ * @typeParam GlobalParamsSchema - Global params schema
+ * @remarks The App keeps this typed and uses it to generate provider.environment.
+ */
+interface GlobalParamsNode<GlobalParamsSchema extends ZodObject<ZodRawShape>> extends EnvKeysNode<GlobalParamsSchema> {
+    params: z.infer<GlobalParamsSchema>;
+}
+/** Authoring input — stage: per-stage params + envKeys. */
+/**
+ * Concrete per‑stage configuration for authoring (params + env exposure).
+ *
+ * @typeParam StageParamsSchema - Per‑stage params schema
+ * @remarks The App composes stage with global (global.partial().extend(stage)).
+ */
+interface StageParamsNode<StageParamsSchema extends ZodObject<ZodRawShape>> extends EnvKeysNode<StageParamsSchema> {
+    params: Record<string, z.infer<StageParamsSchema>>;
+}
+/** Authoring input for unified app config (serverless + env). */
+/**
+ * Authoring input for a complete, unified app configuration.
+ *
+ * @typeParam GlobalParamsSchema - Global params schema
+ * @typeParam StageParamsSchema  - Per‑stage params schema
+ * @remarks Use with {@link defineAppConfig}.
+ */
+interface DefineAppConfigInput<GlobalParamsSchema extends ZodObject<ZodRawShape>, StageParamsSchema extends ZodObject<ZodRawShape>> {
+    serverless: {
+        defaultHandlerFileName: string;
+        defaultHandlerFileExport: string;
+        httpContextEventMap: SecurityContextHttpEventMap$1;
+    };
+    global: GlobalParamsNode<GlobalParamsSchema>;
+    stage: StageParamsNode<StageParamsSchema>;
+}
+/**
+ * Output of {@link defineAppConfig}.
+ *
+ * Carries serverless defaults, stage artifacts, and typed env nodes suitable
+ * for passing directly to SMOZ wrappers.
+ */
+interface DefineAppConfigOutput<GlobalParamsSchema extends ZodObject<ZodRawShape>, StageParamsSchema extends ZodObject<ZodRawShape>> extends GlobalEnvConfig<GlobalParamsSchema, StageParamsSchema> {
+    serverless: DefineAppConfigInput<GlobalParamsSchema, StageParamsSchema>['serverless'];
+    stages: ReturnType<typeof stagesFactory>['stages'];
+    environment: ReturnType<typeof stagesFactory>['environment'];
+    buildFnEnv: ReturnType<typeof stagesFactory>['buildFnEnv'];
+}
+/**
+ * Define a complete application configuration from schemas and authoring input.
+ *
+ * @typeParam GlobalParamsSchema - Global params schema
+ * @typeParam StageParamsSchema  - Per‑stage params schema
+ * @param globalParamsSchema - schema for global params
+ * @param stageParamsSchema  - schema for stage params
+ * @param input - serverless defaults and concrete params + env exposure
+ * @returns Typed configuration nodes and stage artifacts
+ * * @throws Error if envKeys include keys not present in their corresponding schema
+ */
+declare function defineAppConfig<GlobalParamsSchema extends ZodObject<ZodRawShape>, StageParamsSchema extends ZodObject<ZodRawShape>>(globalParamsSchema: GlobalParamsSchema, stageParamsSchema: StageParamsSchema, input: DefineAppConfigInput<GlobalParamsSchema, StageParamsSchema>): DefineAppConfigOutput<GlobalParamsSchema, StageParamsSchema>;
+
+/** Classify the security context from either API Gateway event version. */
+/**
+ * Detect security context from API Gateway v1/v2 events.
+ *
+ * @param evt - unknown event
+ * @returns 'my' when authorized (Cognito/JWT/IAM), 'private' when API key present, else 'public'
+ */
+declare const detectSecurityContext: (evt: unknown) => HttpContext$1;
+
+/**
+ * Wrap a business handler with SMOZ runtime. *
+ * - HTTP event tokens receive the full Middy pipeline (validation, shaping, CORS, etc.)
+ * - Non‑HTTP tokens bypass Middy and call the business function directly.
+ *
+ * @typeParam GlobalParamsSchema - global params schema type
+ * @typeParam StageParamsSchema  - stage params schema type
+ * @typeParam EventTypeMap       - event token → runtime type map
+ * @typeParam EventType          - a key of EventTypeMap
+ * @typeParam EventSchema        - optional Zod schema for event (validated before handler)
+ * @typeParam ResponseSchema     - optional Zod schema for response (validated after handler)
+ * @param functionConfig - per‑function configuration (branded with env nodes)
+ * @param business - the business handler implementation
+ * @param opts - optional runtime overrides (e.g., widen HTTP tokens)
+ * @returns a Lambda‑compatible handler function
+ */
+declare function wrapHandler<GlobalParamsSchema extends ZodObject<ZodRawShape>, StageParamsSchema extends ZodObject<ZodRawShape>, EventTypeMap extends BaseEventTypeMap, EventType extends keyof EventTypeMap, EventSchema extends z.ZodType | undefined, ResponseSchema extends z.ZodType | undefined>(functionConfig: FunctionConfig<EventSchema, ResponseSchema, z.infer<GlobalParamsSchema>, z.infer<StageParamsSchema>, EventTypeMap, EventType> & EnvAttached<GlobalParamsSchema, StageParamsSchema>, business: Handler$1<EventSchema, ResponseSchema, EventTypeMap[EventType]>, opts?: {
+    httpEventTypeTokens?: readonly string[];
+    httpConfig?: AppHttpConfig$1;
+}): (event: unknown, context: Context) => Promise<any>;
+
+/**
+ * HTTP customization types and aliases.
+ */
+
+type ApiMiddleware$1 = MiddlewareObj<APIGatewayProxyEvent, Context>;
+type HttpStackOptions = {
+    contentType?: string;
+    logger?: ConsoleLogger$1;
+    contentNegotiation?: Parameters<typeof httpContentNegotiation>[0];
+    cors?: Parameters<typeof httpCors>[0];
+    errorHandler?: Parameters<typeof httpErrorHandler>[0];
+    serializer?: {
+        json?: {
+            label?: string;
+            stringify?: (value: unknown) => string;
+        };
+    };
+    jsonBodyParser?: Parameters<typeof httpJsonBodyParser>[0];
+    headerNormalizer?: Parameters<typeof httpHeaderNormalizer>[0];
+};
+type Extend = {
+    before?: ApiMiddleware$1[];
+    after?: ApiMiddleware$1[];
+    onError?: ApiMiddleware$1[];
+};
+type HttpProfile = HttpStackOptions & {
+    extend?: Extend;
+    transform?: HttpTransform;
+};
+type AppHttpConfig = {
+    defaults?: HttpStackOptions & {
+        extend?: Extend;
+        transform?: HttpTransform;
+    };
+    profiles?: Record<string, HttpProfile>;
+};
+type FunctionHttpConfig = {
+    profile?: string;
+    options?: Partial<HttpStackOptions>;
+    extend?: Extend;
+    transform?: HttpTransform;
+    replace?: {
+        stack: MiddlewareObj | PhasedArrays;
+    };
+};
+
+type M = ApiMiddleware$1;
+declare const buildDefaultPhases: (args: {
+    contentType: string;
+    logger: ConsoleLogger$1;
+    opts?: HttpStackOptions;
+    eventSchema?: z.ZodType | undefined;
+    responseSchema?: z.ZodType | undefined;
+}) => {
+    before: M[];
+    after: M[];
+    onError: M[];
+};
+/** Public helper: build default phases suitable for replace scenarios. */
+type BuildSafeDefaultsArgs = Parameters<typeof buildDefaultPhases>[0];
+declare const buildSafeDefaults: (args: BuildSafeDefaultsArgs) => {
+    before: M[];
+    after: M[];
+    onError: M[];
+};
+
+/**
+ * Transform helpers for HTTP middleware stacks.
+ *
+ * - Steps are identified by a non-enumerable __id property on MiddlewareObj.
+ * - Utilities operate on arrays immutably and return new arrays.
+ * * Requirements addressed:
+ * - insertBefore, insertAfter, replaceStep, removeStep, findIndex, getId
+ */
+
+type ApiMiddleware = MiddlewareObj<APIGatewayProxyEvent, Context>;
+type StepId = 'head' | 'header-normalizer' | 'event-normalizer' | 'content-negotiation' | 'json-body-parser' | 'zod-before' | 'head-finalize' | 'zod-after' | 'error-expose' | 'error-handler' | 'cors' | 'preferred-media' | 'shape' | 'serializer';
+/** Attach a non-enumerable __id to a middleware step. */
+declare const tagStep: (mw: ApiMiddleware, id: StepId) => ApiMiddleware;
+/** Retrieve a step's id, if present. */
+declare const getId: (mw: ApiMiddleware) => StepId | undefined;
+/** Find index of a step by id. */
+declare const findIndex: (list: ApiMiddleware[], id: StepId) => number;
+/** Insert a step before the step with given id. */
+declare const insertBefore: (list: ApiMiddleware[], id: StepId, mw: ApiMiddleware) => ApiMiddleware[];
+/** Insert a step after the step with given id. */
+declare const insertAfter: (list: ApiMiddleware[], id: StepId, mw: ApiMiddleware) => ApiMiddleware[];
+/** Replace a step with given id. */
+declare const replaceStep: (list: ApiMiddleware[], id: StepId, mw: ApiMiddleware) => ApiMiddleware[];
+/** Remove a step with given id. */
+declare const removeStep: (list: ApiMiddleware[], id: StepId) => ApiMiddleware[];
+
+/** HTTP methods supported from zod-openapi's PathItem shape (excluding helper 'id'). */
+type MethodKey = keyof Omit<ZodOpenApiPathItemObject, 'id'>;
+
+/** Event type after applying deep schema overrides. */
+/**
+ * Compute the event type as seen by a business handler after Zod overrides.
+ */
+type ShapedEvent<EventSchema extends z.ZodType | undefined, EventType> = EventSchema extends z.ZodType ? DeepOverride<EventType, z.infer<EventSchema>> : EventType;
+/** Handler options shared across invocation modes. */
+type HandlerOptions = {
+    env: Record<string, unknown>;
+    /** Present only for HTTP calls; omitted for SQS/Step/etc. */
+    securityContext?: unknown;
+    /** REQUIRED and must satisfy ConsoleLogger. */
+    logger: ConsoleLogger$1;
+};
+/** Business handler: returns raw payloads; wrapping layers handle HTTP shaping when applicable. */
+/**
+ * Business handler signature used by SMOZ.
+ *
+ * @returns the raw payload; the wrapper applies HTTP shaping when applicable.
+ */
+type Handler<EventSchema extends z.ZodType | undefined, ResponseSchema extends z.ZodType | undefined, EventType> = (event: ShapedEvent<EventSchema, EventType>, context: Context, options: HandlerOptions) => Promise<ResponseSchema extends z.ZodType ? z.infer<ResponseSchema> : unknown>;
+
+/** Security context classification used throughout the handlers. */
+/**
+ * HTTP security context tokens.
+ */
+type HttpContext = 'my' | 'private' | 'public';
+
+/**
+ * REQUIREMENTS ADDRESSED
+ * - Provide a minimal generic Lambda event shape that is compatible with
+ *   common authoring patterns. Zod schemas will refine this via deep override.
+ *
+ * @remarks
+ * Used for internal/non‑HTTP flows when a narrow event type is not desirable.
+ */
+type LambdaEvent = Record<string, unknown>;
+
+type ConsoleLogger = Pick<Console, 'debug' | 'error' | 'info' | 'log'>;
+
+/**
+ * Opaque Serverless event fragments keyed by security context.
+ *
+ * @remarks
+ * Shape is intentionally platform‑specific; used by the App to decorate
+ * generated HTTP events based on 'my' | 'private' | 'public' contexts.
+ */
+type SecurityContextHttpEventMap = Record<HttpContext$1, Partial<PropFromUnion<PropFromUnion<PropFromUnion<AWS['functions'], string>['events'], number>, 'http'>>>;
+
+/** Normalize a path to POSIX separators. */
+declare const toPosixPath: (p: string) => string;
+/**
+ * Resolve a directory path relative to the current module URL and normalize it.
+ *
+ * @param metaUrl - typically import.meta.url
+ * @param levelsUp - how many directory levels to ascend (default: 1)
+ * @returns absolute, POSIX-normalized directory path
+ */
+declare const dirFromHere: (metaUrl: string, levelsUp?: number) => string;
+
+export { App, baseEventTypeMapSchema, buildSafeDefaults, defineAppConfig, detectSecurityContext, dirFromHere, findIndex, getId, insertAfter, insertBefore, removeStep, replaceStep, tagStep, toPosixPath, wrapHandler };
+export type { AppHttpConfig, AppInit, ConsoleLogger, DefineAppConfigInput, DefineAppConfigOutput, EnvKeysNode, EnvSchemaNode, FunctionHttpConfig, GlobalEnvConfig, GlobalParamsNode, Handler, HandlerOptions, HttpContext, HttpProfile, HttpStackOptions, LambdaEvent, MethodKey, SecurityContextHttpEventMap, ShapedEvent, StageParamsNode };