@comity/storefront 0.9.0

package/dist/esm/errors/index.js

@@ -0,0 +1,2 @@
+export { StorefrontError } from "./storefront-error.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/errors/storefront-error.js

@@ -0,0 +1,50 @@
+import { BaseError } from "@comity/primitives/errors";
+/**
+ * Human-friendly messages mapped by reason.
+ */
+const REASON_MESSAGES = {
+    invalid_input: "Invalid input provided",
+    customer_not_found: "Customer not found",
+    address_not_found: "Address not found",
+    product_not_found: "Product not found",
+    payment_failed: "Payment processing failed",
+    order_failed: "Order processing failed",
+    internal_error: "Internal storefront error",
+    compensation_failed: "Payment compensation failed",
+};
+/**
+ * Default HTTP status mapped by reason.
+ */
+const REASON_HTTP_STATUS = {
+    invalid_input: 400,
+    customer_not_found: 404,
+    address_not_found: 404,
+    product_not_found: 404,
+    payment_failed: 402,
+    order_failed: 500,
+    internal_error: 500,
+    compensation_failed: 500,
+};
+/**
+ * Storefront application error.
+ *
+ * Represents an error at the Application layer that wraps domain errors
+ * from Core Modules and adds application-level context.
+ */
+export class StorefrontError extends BaseError {
+    /** Namespaced error code. */
+    code;
+    /**
+     * @param reason - The reason for the storefront error.
+     * @param meta - Additional metadata for the error.
+     */
+    constructor(reason, meta) {
+        super(REASON_MESSAGES[reason], {
+            httpStatus: REASON_HTTP_STATUS[reason],
+            ...meta,
+            reason,
+        });
+        this.code = `storefront:${reason}`;
+    }
+}
+//# sourceMappingURL=storefront-error.js.map

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export { DefaultCategoryPageComposer } from "./composers/category.js";
+export { DefaultContentPageComposer } from "./composers/content.js";
+export { DefaultProductPageComposer } from "./composers/product.js";
+export { DefaultSearchPageComposer } from "./composers/search.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/setup/composition.js

@@ -0,0 +1,43 @@
+import { success } from "@comity/primitives/result";
+import { DefaultCategoryPageComposer } from "../composers/category.js";
+import { DefaultContentPageComposer } from "../composers/content.js";
+import { DefaultProductPageComposer } from "../composers/product.js";
+import { DefaultSearchPageComposer } from "../composers/search.js";
+import { CATEGORY_PAGE_COMPOSER_TOKEN, CONTENT_PAGE_COMPOSER_TOKEN, PRODUCT_PAGE_COMPOSER_TOKEN, SEARCH_PAGE_COMPOSER_TOKEN, } from "./constants.js";
+export default {
+    name: "@comity/storefront",
+    version: "0.9.0",
+    dependsOn: {
+        "@comity/catalog": { optional: false },
+        "@comity/taxonomy": { optional: false },
+        "@comity/content": { optional: false },
+    },
+    incompatibleWith: [],
+    /** @inheritdoc */
+    setup: async (ctx, options = {}) => {
+        const initial = {
+            product: [],
+            category: [],
+            content: [],
+            search: [],
+        };
+        let enrichers = initial;
+        // Execute configuring hook to allow enrichment customization
+        enrichers = await ctx.hooks.execute("@comity/storefront:configuring", enrichers);
+        // Product
+        ctx.services.define(PRODUCT_PAGE_COMPOSER_TOKEN, () => new DefaultProductPageComposer(options.productRepository, enrichers.product));
+        // Category
+        ctx.services.define(CATEGORY_PAGE_COMPOSER_TOKEN, () => new DefaultCategoryPageComposer(options.taxonomyRepository, enrichers.category));
+        // Content
+        ctx.services.define(CONTENT_PAGE_COMPOSER_TOKEN, () => new DefaultContentPageComposer(options.pageRepository, enrichers.content));
+        // Search — Phase 15: consumes `SearchPort<ProductProjection>`,
+        // not `ProductRepository.search()`. The composition layer is
+        // the only place that wires a repository together with a search port.
+        ctx.services.define(SEARCH_PAGE_COMPOSER_TOKEN, () => new DefaultSearchPageComposer(options.productSearchPort, enrichers.search));
+        return success(async () => {
+            await ctx.hooks.execute("@comity/storefront:initialized", undefined);
+            return success(undefined);
+        });
+    },
+};
+//# sourceMappingURL=composition.js.map

package/dist/esm/setup/constants.js

@@ -0,0 +1,5 @@
+export const CATEGORY_PAGE_COMPOSER_TOKEN = Symbol("@comity/storefront:category-page");
+export const CONTENT_PAGE_COMPOSER_TOKEN = Symbol("@comity/storefront:content-page");
+export const PRODUCT_PAGE_COMPOSER_TOKEN = Symbol("@comity/storefront:product-page");
+export const SEARCH_PAGE_COMPOSER_TOKEN = Symbol("@comity/storefront:search-page");
+//# sourceMappingURL=constants.js.map

package/dist/esm/setup/index.js

@@ -0,0 +1,3 @@
+export { default } from "./composition.js";
+export { CATEGORY_PAGE_COMPOSER_TOKEN, CONTENT_PAGE_COMPOSER_TOKEN, PRODUCT_PAGE_COMPOSER_TOKEN, SEARCH_PAGE_COMPOSER_TOKEN, } from "./constants.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/setup/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types/composers/category.d.ts

@@ -0,0 +1,20 @@
+import type { TaxonomyRepository } from "@comity/taxonomy";
+import type { RepositoryError } from "@comity/primitives/errors";
+import { type Result } from "@comity/primitives/result";
+import type { CategoryPageComposer, CategoryPageEnricher, CategoryPageModel } from "../contracts/category-page.js";
+import type { StorefrontContext } from "../contracts/context.js";
+/**
+ * Default implementation of the CategoryPageComposer interface, responsible for presenting category pages in the storefront.
+ */
+export declare class DefaultCategoryPageComposer implements CategoryPageComposer {
+    #private;
+    /**
+     * @param repository - The taxonomy repository to use for fetching category data.
+     * @param enrichers - Optional array of enrichers to apply to the category page model.
+     */
+    constructor(repository: TaxonomyRepository, enrichers?: ReadonlyArray<CategoryPageEnricher>);
+    /**
+     * @inheritdoc
+     */
+    compose(id: string, ctx: StorefrontContext): Promise<Result<CategoryPageModel, RepositoryError>>;
+}

package/dist/types/composers/content.d.ts

@@ -0,0 +1,20 @@
+import type { PageRepository } from "@comity/content";
+import type { RepositoryError } from "@comity/primitives/errors";
+import { type Result } from "@comity/primitives/result";
+import type { ContentPageComposer, ContentPageEnricher, ContentPageModel } from "../contracts/content-page.js";
+import type { StorefrontContext } from "../contracts/context.js";
+/**
+ * Default implementation of the ContentPageComposer interface.
+ */
+export declare class DefaultContentPageComposer implements ContentPageComposer {
+    #private;
+    /**
+     * @param repository - Page repository used to fetch content page data.
+     * @param enrichers - Optional enrichers to apply after base composition.
+     */
+    constructor(repository: PageRepository, enrichers?: ReadonlyArray<ContentPageEnricher>);
+    /**
+     * @inheritdoc
+     */
+    compose(id: string, ctx: StorefrontContext): Promise<Result<ContentPageModel, RepositoryError>>;
+}

package/dist/types/composers/product.d.ts

@@ -0,0 +1,20 @@
+import type { ProductRepository } from "@comity/catalog";
+import type { RepositoryError } from "@comity/primitives/errors";
+import { type Result } from "@comity/primitives/result";
+import type { StorefrontContext } from "../contracts/context.js";
+import type { ProductPageComposer, ProductPageEnricher, ProductPageModel } from "../contracts/product-page.js";
+/**
+ * Default implementation of the ProductPageComposer interface.
+ */
+export declare class DefaultProductPageComposer implements ProductPageComposer {
+    #private;
+    /**
+     * @param repository - Product repository used to fetch product data.
+     * @param enrichers - Optional enrichers to apply after base composition.
+     */
+    constructor(repository: ProductRepository, enrichers?: ReadonlyArray<ProductPageEnricher>);
+    /**
+     * @inheritdoc
+     */
+    compose(id: string, ctx: StorefrontContext): Promise<Result<ProductPageModel, RepositoryError>>;
+}

package/dist/types/composers/search.d.ts

@@ -0,0 +1,26 @@
+import type { ProductProjection } from "@comity/catalog";
+import type { SearchPort } from "@comity/search";
+import type { SearchError } from "@comity/search/errors";
+import { type Result } from "@comity/primitives/result";
+import type { StorefrontContext } from "../contracts/context.js";
+import type { SearchPageComposer, SearchPageEnricher, SearchPageModel } from "../contracts/search-page.js";
+/**
+ * Default implementation of the SearchPageComposer interface.
+ *
+ * Phase 15 — product search is consumed via the search-owned
+ * `SearchPort<ProductProjection>` port, NOT via `ProductRepository.search`.
+ * The storefront composition layer is the only place that wires a
+ * `ProductRepository` together with a `SearchPort<ProductProjection>`.
+ */
+export declare class DefaultSearchPageComposer implements SearchPageComposer {
+    #private;
+    /**
+     * @param search - Search port used to execute product search queries.
+     * @param enrichers - Optional enrichers to apply after base composition.
+     */
+    constructor(search: SearchPort<ProductProjection>, enrichers?: ReadonlyArray<SearchPageEnricher>);
+    /**
+     * @inheritdoc
+     */
+    compose(query: string, ctx: StorefrontContext): Promise<Result<SearchPageModel, SearchError>>;
+}

package/dist/types/contracts/category-page.d.ts

@@ -0,0 +1,48 @@
+import type { ProductProjection } from "@comity/catalog";
+import type { BreadcrumbModel } from "@comity/content";
+import type { RepositoryError } from "@comity/primitives/errors";
+import type { Result } from "@comity/primitives/result";
+import type { CategoryModel } from "@comity/taxonomy";
+import type { StorefrontContext } from "./context.js";
+import type { StorefrontPageModel } from "./page.js";
+/**
+ * Category page model for storefront.
+ */
+export interface CategoryPageModel extends StorefrontPageModel {
+    /** The type of the page, fixed to "category" for category pages. */
+    readonly type: "category";
+    /** Category model for the category page. */
+    readonly category: CategoryModel | null;
+    /** Product models for the category page. */
+    readonly products: ReadonlyArray<ProductProjection>;
+    /** Breadcrumbs for the category page. */
+    readonly breadcrumbs?: readonly BreadcrumbModel[];
+}
+/**
+ * Composer for category pages in the storefront.
+ */
+export interface CategoryPageComposer {
+    /**
+     * Compose a category page by ID and context.
+     *
+     * @param id - The identifier of the category to compose.
+     * @param context - The storefront context for the composition, including locale, currency, and tenant information.
+     *
+     * @returns The composed category page model or an error if the composition fails.
+     */
+    compose(id: string, context: StorefrontContext): Promise<Result<CategoryPageModel, RepositoryError>>;
+}
+/**
+ * Enricher for category pages in the storefront.
+ */
+export interface CategoryPageEnricher {
+    /**
+     * Enrich an existing page model.
+     *
+     * @param page - The category page model to enrich.
+     * @param ctx - The storefront context for the enrichment, including locale, currency, and tenant information.
+     *
+     * @returns The enriched category page model or an error if the enrichment fails.
+     */
+    enrich(page: CategoryPageModel, ctx: StorefrontContext): Promise<Result<CategoryPageModel, RepositoryError>>;
+}

package/dist/types/contracts/content-page.d.ts

@@ -0,0 +1,42 @@
+import type { BreadcrumbModel } from "@comity/content";
+import type { RepositoryError } from "@comity/primitives/errors";
+import type { Result } from "@comity/primitives/result";
+import type { StorefrontContext } from "./context.js";
+import type { StorefrontPageModel } from "./page.js";
+/**
+ * Content page model for storefront.
+ */
+export interface ContentPageModel extends StorefrontPageModel {
+    /** The type of the page, fixed to "content" for content pages. */
+    readonly type: "content";
+    /** Breadcrumbs for the content page. */
+    readonly breadcrumbs?: readonly BreadcrumbModel[];
+}
+/**
+ * Composer for content pages in the storefront.
+ */
+export interface ContentPageComposer {
+    /**
+     * Compose a content page by ID and context.
+     *
+     * @param id - The identifier of the content to compose.
+     * @param context - The storefront context for the composition, including locale, currency, and tenant information.
+     *
+     * @returns The composed content page model or an error if the composition fails.
+     */
+    compose(id: string, context: StorefrontContext): Promise<Result<ContentPageModel, RepositoryError>>;
+}
+/**
+ * Enricher for content pages in the storefront.
+ */
+export interface ContentPageEnricher {
+    /**
+     * Enrich an existing content page model.
+     *
+     * @param page - The content page model to enrich.
+     * @param ctx - The storefront context for enrichment.
+     *
+     * @returns The enriched content page model or an error if enrichment fails.
+     */
+    enrich(page: ContentPageModel, ctx: StorefrontContext): Promise<Result<ContentPageModel, RepositoryError>>;
+}

package/dist/types/contracts/context.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Storefront context
+ */
+export interface StorefrontContext {
+    /** Locale for the request. */
+    readonly locale?: string;
+    /** Currency for the request. */
+    readonly currency?: string;
+    /** Optional tenant ID to fetch catalog data for a specific tenant. */
+    readonly tenant?: string;
+}
+/**
+ * Transport-neutral request input used to resolve the storefront context.
+ */
+export interface StorefrontContextInput {
+    /** Request URL. */
+    readonly url: URL;
+    /** Request headers. */
+    readonly headers: Readonly<Record<string, string>>;
+    /** Request cookies. */
+    readonly cookies: Readonly<Record<string, string>>;
+}
+/**
+ * Resolves the storefront context for incoming requests, including locale, currency, and tenant information.
+ */
+export interface StorefrontContextResolver {
+    /** Resolves the storefront context for the given request input. */
+    resolve(input: StorefrontContextInput): Promise<StorefrontContext>;
+}

package/dist/types/contracts/page.d.ts

@@ -0,0 +1,8 @@
+import type { PageModel } from "@comity/content";
+/**
+ * Represents a generic storefront page model.
+ */
+export interface StorefrontPageModel extends PageModel {
+    /** The type of the page. */
+    readonly type: string;
+}

package/dist/types/contracts/product-page.d.ts

@@ -0,0 +1,45 @@
+import type { ProductProjection } from "@comity/catalog";
+import type { BreadcrumbModel } from "@comity/content";
+import type { RepositoryError } from "@comity/primitives/errors";
+import type { Result } from "@comity/primitives/result";
+import type { StorefrontContext } from "./context.js";
+import type { StorefrontPageModel } from "./page.js";
+/**
+ * Product page model for storefront.
+ */
+export interface ProductPageModel extends StorefrontPageModel {
+    /** The type of the page, fixed to "product" for product pages. */
+    readonly type: "product";
+    /** Product model for the product page. */
+    readonly product: ProductProjection | null;
+    /** Breadcrumbs for the product page. */
+    readonly breadcrumbs?: readonly BreadcrumbModel[];
+}
+/**
+ * Composer for product pages in the storefront.
+ */
+export interface ProductPageComposer {
+    /**
+     * Compose a product page by ID and context.
+     *
+     * @param id - The identifier of the product to compose.
+     * @param context - The storefront context for the composition, including locale, currency, and tenant information.
+     *
+     * @returns The composed product page model or an error if the composition fails.
+     */
+    compose(id: string, context: StorefrontContext): Promise<Result<ProductPageModel, RepositoryError>>;
+}
+/**
+ * Enricher for product pages in the storefront.
+ */
+export interface ProductPageEnricher {
+    /**
+     * Enrich an existing product page model.
+     *
+     * @param page - The product page model to enrich.
+     * @param ctx - The storefront context for enrichment.
+     *
+     * @returns The enriched product page model or an error if enrichment fails.
+     */
+    enrich(page: ProductPageModel, ctx: StorefrontContext): Promise<Result<ProductPageModel, RepositoryError>>;
+}

package/dist/types/contracts/search-page.d.ts

@@ -0,0 +1,49 @@
+import type { ProductProjection } from "@comity/catalog";
+import type { Result } from "@comity/primitives/result";
+import type { SearchError } from "@comity/search/errors";
+import type { SearchResultModel } from "@comity/search";
+import type { StorefrontContext } from "./context.js";
+import type { StorefrontPageModel } from "./page.js";
+/**
+ * Search page model for storefront.
+ */
+export interface SearchPageModel extends StorefrontPageModel {
+    /** The type of the page, fixed to "search" for search pages. */
+    readonly type: "search";
+    /** The search query for the search page. */
+    readonly query: string;
+    /** Product models for the search page. */
+    readonly result: SearchResultModel<ProductProjection>;
+}
+/**
+ * Composer for search pages in the storefront.
+ *
+ * Phase 15 — failures surface as `SearchError` from `@comity/search/errors`,
+ * not `RepositoryError`. The composer delegates execution to a
+ * `SearchPort<ProductProjection>` and never reaches into a domain repository.
+ */
+export interface SearchPageComposer {
+    /**
+     * Compose a search page by query and context.
+     *
+     * @param query - The search query to compose.
+     * @param context - The storefront context for the composition, including locale, currency, and tenant information.
+     *
+     * @returns The composed search page model or an error if the composition fails.
+     */
+    compose(query: string, context: StorefrontContext): Promise<Result<SearchPageModel, SearchError>>;
+}
+/**
+ * Enricher for search pages in the storefront.
+ */
+export interface SearchPageEnricher {
+    /**
+     * Enrich an existing search page model.
+     *
+     * @param page - The search page model to enrich.
+     * @param ctx - The storefront context for enrichment.
+     *
+     * @returns The enriched search page model or an error if enrichment fails.
+     */
+    enrich(page: SearchPageModel, ctx: StorefrontContext): Promise<Result<SearchPageModel, SearchError>>;
+}

package/dist/types/errors/index.d.ts

@@ -0,0 +1,2 @@
+export type { StorefrontErrorMeta, StorefrontErrorReason } from "./storefront-error.js";
+export { StorefrontError } from "./storefront-error.js";

package/dist/types/errors/storefront-error.d.ts

@@ -0,0 +1,43 @@
+import type { ErrorMeta } from "@comity/primitives/errors";
+import { BaseError } from "@comity/primitives/errors";
+/**
+ * Reasons for storefront errors.
+ *
+ * @remarks
+ * These reasons categorize application-level failures in the storefront.
+ * Core module errors are wrapped and re-exposed with their original reasons.
+ */
+export type StorefrontErrorReason = "invalid_input" | "customer_not_found" | "address_not_found" | "product_not_found" | "payment_failed" | "order_failed" | "internal_error" | "compensation_failed";
+/**
+ * Metadata attached to storefront errors.
+ */
+export interface StorefrontErrorMeta extends ErrorMeta {
+    /** Error reason. */
+    readonly reason: StorefrontErrorReason;
+    /** Optional diagnostic details. */
+    readonly details?: Readonly<{
+        /** Affected entity identifier. */
+        entityId?: string;
+        /** Entity type (e.g., "customer", "address", "product", "order"). */
+        entityType?: string;
+        /** Wrapped error code, if any. */
+        wrappedCode?: string;
+        /** Wrapped error reason, if any. */
+        wrappedReason?: string;
+    }>;
+}
+/**
+ * Storefront application error.
+ *
+ * Represents an error at the Application layer that wraps domain errors
+ * from Core Modules and adds application-level context.
+ */
+export declare class StorefrontError extends BaseError<StorefrontErrorMeta> {
+    /** Namespaced error code. */
+    readonly code: `storefront:${StorefrontErrorReason}`;
+    /**
+     * @param reason - The reason for the storefront error.
+     * @param meta - Additional metadata for the error.
+     */
+    constructor(reason: StorefrontErrorReason, meta?: Omit<StorefrontErrorMeta, "reason">);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export type { CategoryPageComposer, CategoryPageEnricher, CategoryPageModel, } from "./contracts/category-page.js";
+export type { ContentPageComposer, ContentPageEnricher, ContentPageModel, } from "./contracts/content-page.js";
+export type { StorefrontContext, StorefrontContextInput, StorefrontContextResolver, } from "./contracts/context.js";
+export type { StorefrontPageModel } from "./contracts/page.js";
+export type { ProductPageComposer, ProductPageEnricher, ProductPageModel, } from "./contracts/product-page.js";
+export type { SearchPageComposer, SearchPageEnricher, SearchPageModel, } from "./contracts/search-page.js";
+export { DefaultCategoryPageComposer } from "./composers/category.js";
+export { DefaultContentPageComposer } from "./composers/content.js";
+export { DefaultProductPageComposer } from "./composers/product.js";
+export { DefaultSearchPageComposer } from "./composers/search.js";

package/dist/types/setup/composition.d.ts

@@ -0,0 +1,20 @@
+import type { StorefrontModuleContext, StorefrontModuleOptions } from "./types.js";
+declare const _default: {
+    name: string;
+    version: string;
+    dependsOn: {
+        "@comity/catalog": {
+            optional: false;
+        };
+        "@comity/taxonomy": {
+            optional: false;
+        };
+        "@comity/content": {
+            optional: false;
+        };
+    };
+    incompatibleWith: never[];
+    /** @inheritdoc */
+    setup: (ctx: StorefrontModuleContext, options?: StorefrontModuleOptions) => Promise<import("@comity/primitives/result").ResultSuccess<() => Promise<import("@comity/primitives/result").ResultSuccess<undefined>>>>;
+};
+export default _default;

package/dist/types/setup/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CATEGORY_PAGE_COMPOSER_TOKEN: unique symbol;
+export declare const CONTENT_PAGE_COMPOSER_TOKEN: unique symbol;
+export declare const PRODUCT_PAGE_COMPOSER_TOKEN: unique symbol;
+export declare const SEARCH_PAGE_COMPOSER_TOKEN: unique symbol;

package/dist/types/setup/index.d.ts

@@ -0,0 +1,3 @@
+export type { StorefrontModuleContext, StorefrontModuleEvents, StorefrontModuleHooks, StorefrontModuleOptions, StorefrontModuleServices, } from "./types.js";
+export { default } from "./composition.js";
+export { CATEGORY_PAGE_COMPOSER_TOKEN, CONTENT_PAGE_COMPOSER_TOKEN, PRODUCT_PAGE_COMPOSER_TOKEN, SEARCH_PAGE_COMPOSER_TOKEN, } from "./constants.js";

package/dist/types/setup/types.d.ts

@@ -0,0 +1,70 @@
+import type { ModuleSetupContext } from "@comity/composition/setup";
+import type { ProductProjection, ProductRepository } from "@comity/catalog";
+import type { SearchPort } from "@comity/search";
+import type { PageRepository } from "@comity/content";
+import type { TaxonomyRepository } from "@comity/taxonomy";
+import type { CategoryPageComposer, CategoryPageEnricher } from "../contracts/category-page.js";
+import type { ContentPageComposer, ContentPageEnricher } from "../contracts/content-page.js";
+import type { ProductPageComposer, ProductPageEnricher } from "../contracts/product-page.js";
+import type { SearchPageComposer, SearchPageEnricher } from "../contracts/search-page.js";
+import type { CATEGORY_PAGE_COMPOSER_TOKEN, CONTENT_PAGE_COMPOSER_TOKEN, PRODUCT_PAGE_COMPOSER_TOKEN, SEARCH_PAGE_COMPOSER_TOKEN } from "./constants.js";
+/**
+ * Options for setting up the storefront module.
+ */
+export interface StorefrontOptions {
+    /** Enrichers for the product page. */
+    readonly product: ReadonlyArray<ProductPageEnricher>;
+    /** Enrichers for the category page. */
+    readonly category: ReadonlyArray<CategoryPageEnricher>;
+    /** Enrichers for the content page. */
+    readonly content: ReadonlyArray<ContentPageEnricher>;
+    /** Enrichers for the search page. */
+    readonly search: ReadonlyArray<SearchPageEnricher>;
+}
+/** Hooks exposed by the module */
+export type StorefrontModuleHooks = {
+    /** Executed during module setup, allows modifying initial configuration */
+    "@comity/storefront:configuring": StorefrontOptions;
+    /** Executed when the module is initialized. */
+    "@comity/storefront:initialized": undefined;
+};
+/** Events emitted by the module */
+export type StorefrontModuleEvents = {};
+/**
+ * Services exposed by the module
+ */
+export type StorefrontModuleServices = {
+    /** Category page composer token */
+    [CATEGORY_PAGE_COMPOSER_TOKEN]: CategoryPageComposer;
+    /** Content page composer token */
+    [CONTENT_PAGE_COMPOSER_TOKEN]: ContentPageComposer;
+    /** Product page composer token */
+    [PRODUCT_PAGE_COMPOSER_TOKEN]: ProductPageComposer;
+    /** Search page composer token */
+    [SEARCH_PAGE_COMPOSER_TOKEN]: SearchPageComposer;
+};
+/**
+ * Context provided to the storefront module setup function.
+ */
+export interface StorefrontModuleContext extends ModuleSetupContext<StorefrontModuleServices, StorefrontModuleEvents, StorefrontModuleHooks> {
+}
+/**
+ * Options for setting up the storefront module.
+ */
+export interface StorefrontModuleOptions extends Record<string, unknown> {
+    /** Product repository for page composition */
+    readonly productRepository?: ProductRepository;
+    /**
+     * Product search port.
+     *
+     * Phase 15 — product search is provided via `@comity/search`'s
+     * `SearchPort<ProductProjection>`, NOT via `ProductRepository.search`.
+     * The application/composition layer wires a `ProductRepository`
+     * together with this search port.
+     */
+    readonly productSearchPort?: SearchPort<ProductProjection>;
+    /** Taxonomy repository for category page composition */
+    readonly taxonomyRepository?: TaxonomyRepository;
+    /** Page repository for content page composition */
+    readonly pageRepository?: PageRepository;
+}