@adobe/aio-commerce-lib-app 0.3.2 → 1.0.1

package/dist/es/router-CJ4VWoCt.mjs

@@ -0,0 +1,404 @@
+import { badRequest, internalServerError, methodNotAllowed, notFound } from "@adobe/aio-commerce-lib-core/responses";
+import AioLogger from "@adobe/aio-lib-core-logging";
+import { parse } from "regexparam";
+
+//#region ../../packages-private/common-utils/source/actions/http/middleware/logger.ts
+/**
+* Creates a logger middleware that adds logging capabilities to the context.
+*
+* @example
+* ```typescript
+* router.use(logger({ level: "debug", name: () => "my-logger-name" }));
+*
+* router.get("/test", {
+*   handler: (req, ctx) => {
+*     ctx.logger.info("Hello world");
+*     return ok({ body: {} });
+*   },
+* });
+* ```
+*/
+function logger({ name, ...restOptions } = {}) {
+	return (ctx) => {
+		const params = ctx.rawParams;
+		return { logger: AioLogger(`${params.__ow_method}-${name?.(ctx) ?? process.env.__OW_ACTION_NAME}`, {
+			level: `${params.LOG_LEVEL ?? "info"}`,
+			...restOptions
+		}) };
+	};
+}
+
+//#endregion
+//#region ../../packages-private/common-utils/source/actions/http/utils.ts
+/**
+* Validates input against a Standard Schema and returns a result.
+*
+* @template TInput - The input type expected by the schema
+* @template TOutput - The output type produced by the schema
+* @param schema - A Standard Schema v1 compliant schema
+* @param input - The input data to validate
+* @returns A promise resolving to either success with validated data or failure with issues
+*
+* @example
+* ```typescript
+* const result = await validateSchema(mySchema, userInput);
+* if (result.success) {
+*   console.log(result.data); // Typed as TOutput
+* } else {
+*   console.error(result.issues); // Validation errors
+* }
+* ```
+*/
+async function validateSchema(schema, input) {
+	const result = await schema["~standard"].validate(input);
+	if (result.issues) return {
+		success: false,
+		issues: result.issues.map((issue) => ({
+			message: issue.message,
+			path: issue.path?.map((segment) => typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment)
+		}))
+	};
+	return {
+		success: true,
+		data: result.value
+	};
+}
+/**
+* Parses a request body from OpenWhisk/Runtime.
+* Handles multiple formats:
+* - Base64-encoded strings (__ow_body)
+* - Already-parsed objects
+* - Body properties mixed into args (web actions with JSON content-type)
+*
+* @param owBody - Body from __ow_body (base64 string, JSON string, or object)
+* @param args - Full args object to extract body from if __ow_body is not present
+*
+* @example
+* ```typescript
+* const body = parseRequestBody(params.__ow_body, params);
+* ```
+*/
+function parseRequestBody(owBody, args) {
+	if (owBody) {
+		if (typeof owBody === "object") return owBody;
+		if (typeof owBody === "string") {
+			try {
+				return JSON.parse(owBody);
+			} catch {}
+			try {
+				const decoded = Buffer.from(owBody, "base64").toString();
+				return JSON.parse(decoded);
+			} catch {}
+		}
+	}
+	if (args && typeof args === "object") {
+		const body = {};
+		for (const [key, value] of Object.entries(args)) if (!key.startsWith("__ow_")) body[key] = value;
+		return body;
+	}
+	return {};
+}
+/**
+* Parses query parameters from OpenWhisk/Runtime format.
+*
+* @param queryString - Query string from __ow_query
+* @param fallbackParams - Fallback params object (used when __ow_query is not present)
+* @returns Parsed query parameters as a record
+*
+* @example
+* ```typescript
+* const query = parseQueryParams(params.__ow_query, params);
+* ```
+*/
+function parseQueryParams(queryString, fallbackParams) {
+	if (queryString) return Object.fromEntries(new URLSearchParams(queryString));
+	if (fallbackParams) {
+		const { __ow_method, __ow_path, __ow_headers, __ow_body, __ow_query, ...rest } = fallbackParams;
+		return rest;
+	}
+	return {};
+}
+
+//#endregion
+//#region ../../packages-private/common-utils/source/actions/http/router.ts
+/**
+* HTTP router for Adobe I/O Runtime actions.
+* Provides type-safe routing with schema validation and OpenWhisk integration.
+*
+* @example
+* ```typescript
+* const router = new HttpActionRouter();
+*
+* router.get("/users/:id", {
+*   handler: (req) => ok({ id: req.params.id, context: req.context })
+* });
+*
+* // Add context builders
+* router.use(async (base) => ({
+*   user: await getUser(base.rawParams.__ow_headers?.authorization),
+* }));
+*
+* export const main = router.handler();
+* ```
+*/
+var HttpActionRouter = class {
+	constructor() {
+		this.routes = [];
+		this.contextBuilders = [];
+	}
+	/**
+	* Internal method to add a route to the router.
+	*/
+	addRoute(method, path, config) {
+		const { pattern, keys } = parse(path);
+		this.routes.push({
+			method,
+			pattern,
+			keys,
+			params: config.params,
+			body: config.body,
+			query: config.query,
+			handler: config.handler
+		});
+		return this;
+	}
+	/**
+	* Register a GET route.
+	*
+	* @example
+	* ```typescript
+	* router.get("/users/:id", {
+	*   handler: (req) => ok({ id: req.params.id })
+	* });
+	* ```
+	*/
+	get(path, config) {
+		return this.addRoute("GET", path, config);
+	}
+	/**
+	* Register a POST route.
+	*
+	* @example
+	* ```typescript
+	* router.post("/users", {
+	*   body: userSchema,
+	*   handler: (req) => created(req.body)
+	* });
+	* ```
+	*/
+	post(path, config) {
+		return this.addRoute("POST", path, config);
+	}
+	/**
+	* Register a PUT route.
+	*
+	* @example
+	* ```typescript
+	* router.put("/users/:id", {
+	*   body: userSchema,
+	*   handler: (req) => ok(req.body)
+	* });
+	* ```
+	*/
+	put(path, config) {
+		return this.addRoute("PUT", path, config);
+	}
+	/**
+	* Register a PATCH route.
+	*
+	* @example
+	* ```typescript
+	* router.patch("/users/:id", {
+	*   body: partialUserSchema,
+	*   handler: (req) => ok(req.body)
+	* });
+	* ```
+	*/
+	patch(path, config) {
+		return this.addRoute("PATCH", path, config);
+	}
+	/**
+	* Register a DELETE route.
+	*
+	* @example
+	* ```typescript
+	* router.delete("/users/:id", {
+	*   handler: (req) => noContent()
+	* });
+	* ```
+	*/
+	delete(path, config) {
+		return this.addRoute("DELETE", path, config);
+	}
+	/**
+	* Register a context builder that runs before route handlers.
+	* Context builders can add properties to the request context.
+	* Multiple builders are executed in order and their results are merged.
+	*
+	* The returned router has an updated context type that includes the new properties,
+	* enabling type-safe access in route handlers.
+	*
+	* @param builder - Function that receives base context and returns additional context
+	* @returns The router instance with updated context type for chaining
+	*
+	* @example
+	* ```typescript
+	* const router = new HttpActionRouter()
+	*   .use(logger()) // HttpActionRouter<BaseContext & { logger: Logger }>
+	*   .use(auth());  // HttpActionRouter<BaseContext & { logger: Logger } & { user: User }>
+	*
+	* router.get("/me", {
+	*   handler: (req, ctx) => {
+	*     ctx.logger.info("Hello"); // ✅ typed
+	*     return ok({ body: ctx.user }); // ✅ typed
+	*   },
+	* });
+	* ```
+	*/
+	use(builder) {
+		this.contextBuilders.push(builder);
+		return this;
+	}
+	/**
+	* Builds the full context by running all context builders.
+	*/
+	async buildContext(args) {
+		let context = { rawParams: args };
+		for (const builder of this.contextBuilders) {
+			const result = await builder(context);
+			if (result) context = {
+				...context,
+				...result
+			};
+		}
+		return context;
+	}
+	/**
+	* Validates and extracts route parameters.
+	*/
+	async validateParams(route, params) {
+		if (!route.params) return {
+			success: true,
+			data: params
+		};
+		const result = await validateSchema(route.params, params);
+		if (!result.success) return {
+			success: false,
+			issues: result.issues
+		};
+		return {
+			success: true,
+			data: result.data
+		};
+	}
+	/**
+	* Validates request body.
+	*/
+	async validateBody(route, body) {
+		if (!route.body) return {
+			success: true,
+			data: body
+		};
+		const result = await validateSchema(route.body, body);
+		if (!result.success) return {
+			success: false,
+			issues: result.issues
+		};
+		return {
+			success: true,
+			data: result.data
+		};
+	}
+	/**
+	* Validates query parameters.
+	*/
+	async validateQuery(route, query) {
+		if (!route.query) return {
+			success: true,
+			data: query
+		};
+		const result = await validateSchema(route.query, query);
+		if (!result.success) return {
+			success: false,
+			issues: result.issues
+		};
+		return {
+			success: true,
+			data: result.data
+		};
+	}
+	/** Handles a matched route by validating inputs and calling the handler. */
+	async handleRoute(route, match, body, query, headers, method, path, context) {
+		const params = {};
+		route.keys.forEach((key, i) => {
+			params[key] = decodeURIComponent(match[i + 1] || "");
+		});
+		const paramsResult = await this.validateParams(route, params);
+		if (!paramsResult.success) return badRequest({ body: {
+			message: "Invalid route parameters",
+			issues: paramsResult.issues
+		} });
+		const bodyResult = await this.validateBody(route, body);
+		if (!bodyResult.success) return badRequest({ body: {
+			message: "Invalid request body",
+			issues: bodyResult.issues
+		} });
+		const queryResult = await this.validateQuery(route, query);
+		if (!queryResult.success) return badRequest({ body: {
+			message: "Invalid query parameters",
+			issues: queryResult.issues
+		} });
+		try {
+			return await route.handler({
+				params: paramsResult.data,
+				body: bodyResult.data,
+				query: queryResult.data,
+				headers,
+				method,
+				path
+			}, context);
+		} catch (err) {
+			console.error("Handler error:", err);
+			return internalServerError({ body: {
+				message: "Internal server error",
+				error: err instanceof Error ? err.message : "Unknown error"
+			} });
+		}
+	}
+	/**
+	* Creates an OpenWhisk/Runtime action handler from the registered routes.
+	*
+	* @example
+	* ```typescript
+	* const router = new HttpActionRouter();
+	* router.get("/hello", { handler: () => ok({ message: "Hello!" }) });
+	*
+	* export const main = router.handler();
+	* ```
+	*/
+	handler() {
+		return async (args) => {
+			const method = (args.__ow_method ?? "get").toUpperCase();
+			const rawPath = args.__ow_path ?? "/";
+			const path = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
+			const headers = args.__ow_headers ?? {};
+			const body = parseRequestBody(args.__ow_body, args);
+			const query = parseQueryParams(args.__ow_query, args);
+			const context = await this.buildContext(args);
+			const matchedMethods = [];
+			for (const route of this.routes) {
+				const match = route.pattern.exec(path);
+				if (!match) continue;
+				matchedMethods.push(route.method);
+				if (route.method !== method) continue;
+				const response = await this.handleRoute(route, match, body, query, headers, method, path, context);
+				if (response) return response;
+			}
+			if (matchedMethods.length > 0) return methodNotAllowed(`Method ${method} not allowed`);
+			return notFound(`No route matches ${path}`);
+		};
+	}
+};
+
+//#endregion
+export { logger as n, HttpActionRouter as t };

package/dist/{cjs/index-C5SutkJQ.d.cts → es/runner-BD-lItnK.d.mts}

@@ -1,7 +1,7 @@
-import { n as CommerceAppConfigOutputModel } from "./app-Dx0ca6oL.cjs";
-import { RuntimeActionParams } from "@adobe/aio-commerce-lib-core/params";
-import * as v from "valibot";
+import { n as CommerceAppConfigOutputModel } from "./app-BAiyvNo2.mjs";
 import AioLogger from "@adobe/aio-lib-core-logging";
+import * as v from "valibot";
+import { RuntimeActionParams } from "@adobe/aio-commerce-lib-core/params";
 
 //#region source/management/installation/schema.d.ts
 /** Schema for validating Adobe I/O app credentials required for installation. */
@@ -21,9 +21,7 @@ type AppData = v.InferOutput<typeof AppDataSchema>;
 //#region source/management/installation/workflow/step.d.ts
 /** Shared context available to all steps during installation. */
 type InstallationContext = {
-  /** The credentials of the app being installed */
-  appData: AppData;
-  /** The raw action parameters from the App Builder runtime action. */
+  /** The credentials of the app being installed */appData: AppData; /** The raw action parameters from the App Builder runtime action. */
   params: RuntimeActionParams & {
     AIO_COMMERCE_AUTH_IMS_CLIENT_ID: string;
     AIO_COMMERCE_AUTH_IMS_CLIENT_SECRETS: string | string[];
@@ -31,10 +29,8 @@ type InstallationContext = {
     AIO_COMMERCE_AUTH_IMS_TECHNICAL_ACCOUNT_EMAIL: string;
     AIO_COMMERCE_AUTH_IMS_ORG_ID: string;
     AIO_COMMERCE_AUTH_IMS_SCOPES: string | string[];
-  };
-  /** Logger instance for installation logging. */
-  logger: ReturnType<typeof AioLogger>;
-  /** Custom scripts defined in the configuration (if any). */
+  }; /** Logger instance for installation logging. */
+  logger: ReturnType<typeof AioLogger>; /** Custom scripts defined in the configuration (if any). */
   customScripts?: Record<string, unknown>;
 };
 /** Factory function type for creating step-specific context. */
@@ -48,45 +44,39 @@ type StepMeta = {
 };
 /** Defines the base properties of a step. */
 type StepBase<TName extends string = string, TConfig extends CommerceAppConfigOutputModel = CommerceAppConfigOutputModel> = {
-  /** The name of this step. */
-  name: TName;
-  /** Metadata associated with the step. */
-  meta: StepMeta;
-  /** Whether the step should be taken into consideration. */
+  /** The name of this step. */name: TName; /** Metadata associated with the step. */
+  meta: StepMeta; /** Whether the step should be taken into consideration. */
   when?: (config: CommerceAppConfigOutputModel) => config is TConfig;
 };
 /** A leaf step that executes work (no children). */
-type LeafStep<TName extends string = string, TConfig extends CommerceAppConfigOutputModel = CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>, TOutput$1 = unknown> = StepBase<TName, TConfig> & {
-  type: "leaf";
-  /** The execution handler for the step. */
-  run: (config: TConfig, context: ExecutionContext<TStepCtx>) => TOutput$1 | Promise<TOutput$1>;
+type LeafStep<TName extends string = string, TConfig extends CommerceAppConfigOutputModel = CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown> = StepBase<TName, TConfig> & {
+  type: "leaf"; /** The execution handler for the step. */
+  run: (config: TConfig, context: ExecutionContext<TStepCtx>) => TOutput | Promise<TOutput>;
 };
 /** A branch step that contains children (no execution). */
 type BranchStep<TName extends string = string, TConfig extends CommerceAppConfigOutputModel = CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>> = StepBase<TName, TConfig> & {
-  type: "branch";
-  /** An optional factory function to setup shared context for the children steps. */
-  context?: StepContextFactory<TStepCtx>;
-  /** The children steps of this branch. */
+  type: "branch"; /** An optional factory function to setup shared context for the children steps. */
+  context?: StepContextFactory<TStepCtx>; /** The children steps of this branch. */
   children: AnyStep[];
 };
 /** A step in the installation tree (discriminated union by `type`). */
-type Step<TName extends string = string, TConfig extends CommerceAppConfigOutputModel = CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>, TOutput$1 = unknown> = LeafStep<TName, TConfig, TStepCtx, TOutput$1> | BranchStep<TName, TConfig, TStepCtx>;
+type Step<TName extends string = string, TConfig extends CommerceAppConfigOutputModel = CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown> = LeafStep<TName, TConfig, TStepCtx, TOutput> | BranchStep<TName, TConfig, TStepCtx>;
 /** Loosely-typed step for use in non type-safe contexts. */
 interface AnyStep {
-  type: "leaf" | "branch";
-  name: string;
-  meta: StepMeta;
-  when?: (config: CommerceAppConfigOutputModel) => boolean;
   children?: AnyStep[];
   context?: (context: InstallationContext) => any;
+  meta: StepMeta;
+  name: string;
   run?: (config: any, context: any) => unknown | Promise<unknown>;
+  type: "leaf" | "branch";
+  when?: (config: CommerceAppConfigOutputModel) => boolean;
 }
 /** Check if a step is a leaf step. */
 declare function isLeafStep(step: AnyStep): step is LeafStep;
 /** Check if a step is a branch step. */
 declare function isBranchStep(step: AnyStep): step is BranchStep;
 /** Options for defining a leaf step. */
-type LeafStepOptions<TName extends string, TConfig extends CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>, TOutput$1 = unknown> = Omit<LeafStep<TName, TConfig, TStepCtx, TOutput$1>, "type">;
+type LeafStepOptions<TName extends string, TConfig extends CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown> = Omit<LeafStep<TName, TConfig, TStepCtx, TOutput>, "type">;
 /** Options for defining a branch step. */
 type BranchStepOptions<TName extends string, TConfig extends CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>> = Omit<BranchStep<TName, TConfig, TStepCtx>, "type">;
 /**
@@ -104,7 +94,7 @@ type BranchStepOptions<TName extends string, TConfig extends CommerceAppConfigOu
  * });
  * ```
  */
-declare function defineLeafStep<TName extends string, TConfig extends CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>, TOutput$1 = unknown>(options: LeafStepOptions<TName, TConfig, TStepCtx, TOutput$1>): LeafStep<TName, TConfig, TStepCtx, TOutput$1>;
+declare function defineLeafStep<TName extends string, TConfig extends CommerceAppConfigOutputModel, TStepCtx extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown>(options: LeafStepOptions<TName, TConfig, TStepCtx, TOutput>): LeafStep<TName, TConfig, TStepCtx, TOutput>;
 /**
  * Define a branch step (container with children, no runner).
  *
@@ -130,28 +120,18 @@ type ExecutionStatus = "pending" | "in-progress" | "succeeded" | "failed";
 type InstallationStatus = "pending" | "in-progress" | "succeeded" | "failed";
 /** A structured error with path to the failing step. */
 type InstallationError<TPayload = unknown> = {
-  /** Path to the step that failed (e.g., ["eventing", "commerce", "providers"]). */
-  path: string[];
-  /** Error key for easy identification. */
-  key: string;
-  /** Human-readable error message. */
-  message?: string;
-  /** Additional error payload. */
+  /** Path to the step that failed (e.g., ["eventing", "commerce", "providers"]). */path: string[]; /** Error key for easy identification. */
+  key: string; /** Human-readable error message. */
+  message?: string; /** Additional error payload. */
   payload?: TPayload;
 };
 /** Status of a step in the installation tree. */
 type StepStatus = {
-  /** Step name (unique among siblings). */
-  name: string;
-  /** Unique step identifier (e.g., UUID). */
-  id: string;
-  /** Full path from root to this step. */
-  path: string[];
-  /** Step metadata (for display purposes). */
-  meta: StepMeta;
-  /** Current execution status. */
-  status: ExecutionStatus;
-  /** Child step statuses (empty for leaf steps). */
+  /** Step name (unique among siblings). */name: string; /** Unique step identifier (e.g., UUID). */
+  id: string; /** Full path from root to this step. */
+  path: string[]; /** Step metadata (for display purposes). */
+  meta: StepMeta; /** Current execution status. */
+  status: ExecutionStatus; /** Child step statuses (empty for leaf steps). */
   children: StepStatus[];
 };
 /** Data collected during installation as a nested structure following step paths. */
@@ -160,35 +140,26 @@ type InstallationData = {
 };
 /** Base properties shared by all installation states. */
 type InstallationStateBase = {
-  /** Unique installation identifier. */
-  id: string;
-  /** Root step status. */
-  step: StepStatus;
-  /** Results from executed leaf steps, keyed by path. */
+  /** Unique installation identifier. */id: string; /** Root step status. */
+  step: StepStatus; /** Results from executed leaf steps, keyed by path. */
   data: InstallationData | null;
 };
 /** Installation state when in progress. */
 type InProgressInstallationState = InstallationStateBase & {
-  status: "in-progress";
-  /** ISO timestamp when installation started. */
+  status: "in-progress"; /** ISO timestamp when installation started. */
   startedAt: string;
 };
 /** Installation state when completed successfully. */
 type SucceededInstallationState = InstallationStateBase & {
-  status: "succeeded";
-  /** ISO timestamp when installation started. */
-  startedAt: string;
-  /** ISO timestamp when installation completed. */
+  status: "succeeded"; /** ISO timestamp when installation started. */
+  startedAt: string; /** ISO timestamp when installation completed. */
   completedAt: string;
 };
 /** Installation state when failed. */
 type FailedInstallationState = InstallationStateBase & {
-  status: "failed";
-  /** ISO timestamp when installation started. */
-  startedAt: string;
-  /** ISO timestamp when installation failed. */
-  completedAt: string;
-  /** Error information about the failure. */
+  status: "failed"; /** ISO timestamp when installation started. */
+  startedAt: string; /** ISO timestamp when installation failed. */
+  completedAt: string; /** Error information about the failure. */
   error: InstallationError;
 };
 /**
@@ -213,24 +184,19 @@ type HookFunction<TEvent> = (event: TEvent, state: InstallationState) => void |
 type InstallationHook = (state: InstallationState) => void | Promise<void>;
 /** Base event payload for step events. */
 type StepEvent = {
-  /** Full path to the step (e.g., ["eventing", "commerce", "providers"]). */
-  path: string[];
-  /** Step name (last element of path, for convenience). */
-  stepName: string;
-  /** Whether this is a leaf step (executable) or branch step (container). */
+  /** Full path to the step (e.g., ["eventing", "commerce", "providers"]). */path: string[]; /** Step name (last element of path, for convenience). */
+  stepName: string; /** Whether this is a leaf step (executable) or branch step (container). */
   isLeaf: boolean;
 };
 /** Event payload when a step starts execution. */
 type StepStartedEvent = StepEvent;
 /** Event payload when a step succeeds. */
 type StepSucceededEvent = StepEvent & {
-  /** Result returned by the step (only for leaf steps). */
-  result: unknown;
+  /** Result returned by the step (only for leaf steps). */result: unknown;
 };
 /** Event payload when a step fails. */
 type StepFailedEvent = StepEvent & {
-  /** Error information. */
-  error: InstallationError;
+  /** Error information. */error: InstallationError;
 };
 /** Lifecycle hooks for installation execution. */
 type InstallationHooks = {
@@ -245,22 +211,15 @@ type InstallationHooks = {
 //#region source/management/installation/workflow/runner.d.ts
 /** Options for creating an initial installation state. */
 type CreateInitialStateOptions = {
-  /** The root branch step to build the state from. */
-  rootStep: BranchStep;
-  /** The app configuration used to determine applicable steps. */
+  /** The root branch step to build the state from. */rootStep: BranchStep; /** The app configuration used to determine applicable steps. */
   config: CommerceAppConfigOutputModel;
 };
 /** Options for executing a workflow. */
 type ExecuteWorkflowOptions = {
-  /** The root branch step to execute. */
-  rootStep: BranchStep;
-  /** Shared installation context (params, logger, etc.). */
-  installationContext: InstallationContext;
-  /** The app configuration. */
-  config: CommerceAppConfigOutputModel;
-  /** The initial installation state (with all steps pending). */
-  initialState: InProgressInstallationState;
-  /** Lifecycle hooks for status change notifications. */
+  /** The root branch step to execute. */rootStep: BranchStep; /** Shared installation context (params, logger, etc.). */
+  installationContext: InstallationContext; /** The app configuration. */
+  config: CommerceAppConfigOutputModel; /** The initial installation state (with all steps pending). */
+  initialState: InProgressInstallationState; /** Lifecycle hooks for status change notifications. */
   hooks?: InstallationHooks;
 };
 /**
@@ -317,18 +276,13 @@ declare function defineCustomInstallationStep<TResult = unknown>(handler: Custom
 //#region source/management/installation/runner.d.ts
 /** Options for creating an initial installation state. */
 type CreateInitialInstallationStateOptions = {
-  /** The app configuration used to determine applicable steps. */
-  config: CommerceAppConfigOutputModel;
+  /** The app configuration used to determine applicable steps. */config: CommerceAppConfigOutputModel;
 };
 /** Options for running an installation. */
 type RunInstallationOptions = {
-  /** Shared installation context (params, logger, etc.). */
-  installationContext: InstallationContext;
-  /** The app configuration. */
-  config: CommerceAppConfigOutputModel;
-  /** The initial installation state (with all steps pending). */
-  initialState: InProgressInstallationState;
-  /** Lifecycle hooks for status change notifications. */
+  /** Shared installation context (params, logger, etc.). */installationContext: InstallationContext; /** The app configuration. */
+  config: CommerceAppConfigOutputModel; /** The initial installation state (with all steps pending). */
+  initialState: InProgressInstallationState; /** Lifecycle hooks for status change notifications. */
   hooks?: InstallationHooks;
 };
 /**