@scayle/storefront-cms-contentstack 0.2.0-alpha.0

package/README.md

@@ -0,0 +1,149 @@
+# @scayle/storefront-cms-contentstack
+
+Contentstack CMS provider integration for the SCAYLE Storefront Application V3.
+
+> **Requires Storefront Application V3.** This package implements `CMSProviderService` from
+> `@scayle/storefront`. Controllers resolve the constructed provider from the `ServiceRegistry` and call
+> `fetchPageData`/`fetchListingPageData` directly. It has no standalone use outside a Storefront
+> Application V3 project.
+
+## Package entrypoint
+
+| Export                         | Use                                                                                                                                                             |
+| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ContentstackCMSService`       | Concrete `CMSProviderService` implementation, usable directly since Contentstack's runtime guards are hand-written, not generated.                              |
+| `ContentstackCMSServiceConfig` | Constructor config shape: `{apiKey, deliveryToken, environment, region?, branch?, previewAccessToken?}`.                                                        |
+| `cspConfig`                    | `CMSCspConfig` for the Contentstack Visual Builder: iframe embedding and Live Preview API connect rules, using wildcard subdomains for region-agnostic support. |
+
+See [Contentstack's Content Delivery API documentation](https://www.contentstack.com/docs/developers/apis/content-delivery-api/)
+and the [TypeScript Delivery SDK docs](https://www.contentstack.com/docs/developers/sdks/content-delivery-sdk/typescript/get-started-with-typescript-delivery-sdk)
+for the underlying client.
+
+## Configuration
+
+The boilerplate's `src/server/cms/providers/contentstack/service.ts` reads configuration values from environment variables
+via `getRequiredEnv` and `process.env`, passing them to the `ContentstackCMSService` constructor. See `.env.example` for a
+complete list of environment variables.
+
+| Config field          | Required | Purpose                                                                                                        | Location in Contentstack                                                               | Documentation                                                                                                        |
+| --------------------- | -------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `apiKey`              | Yes      | Stack API key used to authenticate content requests to the Delivery API.                                       | Settings > Stack > API Keys (under "Stack API Key")                                    | [API credentials](https://www.contentstack.com/docs/developers/apis/content-delivery-api#how-to-get-api-credentials) |
+| `deliveryToken`       | Yes      | Delivery token used to authenticate requests for published content.                                            | Settings > Tokens > Delivery Tokens                                                    | [API credentials](https://www.contentstack.com/docs/developers/apis/content-delivery-api#how-to-get-api-credentials) |
+| `environment`         | Yes      | Environment name the service queries (e.g. `production`, `staging`).                                           | Settings > Environments                                                                | [Manage environments](https://www.contentstack.com/docs/developers/set-up-contentstack/manage-multiple-environments) |
+| `region`              | No       | Stack region determining API endpoints (e.g. `US`, `EU`, `AZURE_NA`). Defaults to `US`.                        | Settings > Stack > region shown in API URL or Org settings                             | [About regions](https://www.contentstack.com/docs/developers/set-up-contentstack/about-region)                       |
+| `branch`              | No       | Content branch name for multi-branch workflows (only needed if your stack uses branching).                     | Settings > Branches                                                                    | [Branches guide](https://www.contentstack.com/docs/developers/set-up-contentstack/about-branches)                    |
+| `previewAccessToken`  | No       | Preview token for live preview and Visual Builder requests (required only if using preview/live-preview mode). | Settings > Tokens > Delivery Tokens (preview tokens managed alongside delivery tokens) | [API credentials](https://www.contentstack.com/docs/developers/apis/content-delivery-api#how-to-get-api-credentials) |
+| `draftContentEnabled` | Yes      | Whether draft/unpublished content may be served during an editor session                                       | `STOREFRONT_CMS_ALLOW_DRAFTS` (read by boilerplate)                                    |                                                                                                                      |
+
+Environment variable mapping:
+
+- `CONTENTSTACK_CMS_STACK_API_KEY` → `apiKey`
+- `CONTENTSTACK_CMS_DELIVERY_TOKEN` → `deliveryToken`
+- `CONTENTSTACK_CMS_ENVIRONMENT` → `environment`
+- `CONTENTSTACK_CMS_REGION` → `region`
+- `CONTENTSTACK_CMS_BRANCH` → `branch`
+- `CONTENTSTACK_CMS_PREVIEW_ACCESS_TOKEN` → `previewAccessToken`
+- `STOREFRONT_CMS_ALLOW_DRAFTS` → `draftContentEnabled`
+
+## Usage
+
+Contentstack's page and listing guards are hand-written against a fixed `seo` field shape, not generated
+per-tenant, so `ContentstackCMSService` needs no subclass to fill an abstract method. The boilerplate's
+`src/server/cms/providers/contentstack/service.ts` still wraps it in a thin subclass for consistency with
+the other providers and as the tenant's override point:
+
+```ts
+import { ContentstackCMSService as BaseContentstackCMSService } from '@scayle/storefront-cms-contentstack'
+
+export class ContentstackCMSService extends BaseContentstackCMSService {}
+
+export const createCMSService = (storefront: StorefrontContext) =>
+  new ContentstackCMSService(
+    {
+      apiKey: getRequiredEnv('CONTENTSTACK_CMS_STACK_API_KEY'),
+      deliveryToken: getRequiredEnv('CONTENTSTACK_CMS_DELIVERY_TOKEN'),
+      environment: getRequiredEnv('CONTENTSTACK_CMS_ENVIRONMENT'),
+      region: process.env.CONTENTSTACK_CMS_REGION,
+      branch: process.env.CONTENTSTACK_CMS_BRANCH,
+      previewAccessToken: process.env.CONTENTSTACK_CMS_PREVIEW_ACCESS_TOKEN,
+      draftContentEnabled:
+        process.env.STOREFRONT_CMS_ALLOW_DRAFTS?.toLowerCase() === 'true',
+    },
+    storefront,
+  )
+```
+
+The package never reads `process.env` itself — the boilerplate is the sole place reading environment
+variables, and passes plain values into the constructor.
+
+The boilerplate registers `createCMSService(storefront)` as the `cms` slot on the `ServiceRegistry`
+(`src/server/registries.ts`), alongside every other domain. A controller resolves it from there, calls
+`resolveCmsRequest()` (`src/server/cms/utils/request.ts`) for editor-mode detection and draft handling,
+then calls `fetchPageData`/`fetchListingPageData` directly with the raw request:
+
+```ts
+const { isCmsEditorSession, cmsEditorData } = resolveCmsRequest(
+  this.services.cms,
+  this.ctx.req,
+)
+const pageData = await this.services.cms.fetchPageData(
+  slug,
+  locale,
+  this.ctx.req,
+)
+```
+
+See `@scayle/storefront`'s CMS module for the `CMSProviderService` contract this package implements.
+
+## Architecture
+
+`ContentstackCMSService` implements `CMSProviderService` directly — there is no shared base class.
+Each provider package owns its own caching, error handling, and constructor validation, so this package
+can diverge from Storyblok/Contentful without a `@scayle/storefront` release touching them:
+
+- **`fetchPageData`** and **`fetchListingPageData`** wrap the raw fetch with application-level caching
+  (`context.cache.getOrSet(...)`, 5-minute TTL, bypassed entirely in draft-content mode) under the cache-key
+  patterns `cms:contentstack:page:${slug}:${locale}` and `cms:contentstack:plp:${categoryId}:${locale}`.
+  `fetchListingPageData` also converts a `CMSContentNotFoundError` from the raw fetch into `undefined`
+  (missing PLP content is expected, not an error), logging any other error before rethrowing it.
+- The raw fetches query the `page-component` and `productlistingpage-component` content types by `url`,
+  throwing `CMSContentNotFoundError` when no entry matches. The content-type UID and URL come from
+  `buildPageQuery`/`buildListingQuery`, both `protected` so a subclass can point at a different content
+  type or URL shape without touching live-preview tagging or the shared entry-query chain.
+- A delivery stack is a lazily initialized static singleton, reused across requests. A fresh preview stack
+  is constructed per preview request, since `livePreviewQuery()` mutates the stack's internal config and
+  cannot be shared. Both go through `@scayle/storefront/cms`'s `wrapClientInit`, so a bad API key or
+  environment name fails with a message naming the stack and the config field to check, not a bare SDK
+  error. Constructing a preview stack without a configured `previewAccessToken` throws immediately.
+- Live preview requests are tagged with `contentstack.Utils.addEditableTags(...)` so the Visual Builder can
+  identify editable fields inline.
+- **`isEditorMode`** detects the Contentstack Live Preview / Visual Builder via the `live_preview` query
+  parameter.
+- **`getAdditionalEditorData`** returns the access token, environment, branch, and region the client-side
+  Live Preview SDK needs to connect, read from the constructor's config object, since (unlike Storyblok or
+  Contentful) Contentstack's editor bridge runs entirely client-side.
+- **Draft-content decision**: controlled by the `draftContentEnabled` boolean in the service config, read from
+  the `STOREFRONT_CMS_ALLOW_DRAFTS` environment variable in the boilerplate factory. When both `isEditorMode()`
+  returns true and `draftContentEnabled` is true, the service fetches draft content; otherwise it fetches
+  published content.
+
+**No generated-guard requirement.** Unlike Contentful, Contentstack's page/listing detection
+(`isPageComponent`, `isProductlistingpageComponent` in this package) checks for a fixed `seo` field shape
+rather than delegating to per-tenant generated types, so there is nothing a tenant subclass is required to
+fill in.
+
+## Extending and customizing
+
+Within a tenant project, all customization happens in the boilerplate's
+`src/server/cms/providers/contentstack/service.ts`, by subclassing `ContentstackCMSService`:
+
+- **Content type and URL shape**: override `buildPageQuery(slug)` or `buildListingQuery(categoryId)` to
+  query a different content-type UID or URL field value.
+- **Live preview payload**: override `getAdditionalEditorData` to change which fields the client-side Live
+  Preview SDK receives.
+- **CSP rules**: re-export a modified `cspConfig` (imported from this package as a base) if the tenant needs
+  additional directives beyond the default wildcard Contentstack domains.
+
+Do not reimplement `fetchPageData` or `fetchListingPageData` from scratch. Override only the method that
+needs to change and call `super` for everything else, so the tenant subclass tracks fixes made to this
+package.

package/dist/index.d.mts

@@ -0,0 +1,172 @@
+import { CMSCspConfig, CMSEditorData, CMSPagePayload, CMSProviderService, CMSRequestLike } from "@scayle/storefront/cms";
+import { StorefrontContext } from "@scayle/storefront/types";
+declare module "@scayle/storefront/cms" {
+  interface CMSEditorData {
+    accessToken?: string;
+    environment?: string;
+    branch?: string;
+    region?: string;
+  }
+}
+/**
+ * Configuration accepted by {@link ContentstackCMSService}'s constructor.
+ * The boilerplate reads these from environment variables and passes plain
+ * values in, so this package never touches `process.env` directly.
+ */
+interface ContentstackCMSServiceConfig {
+  /** Stack API key (Stack > Settings > Tokens). Used as `apiKey` in the Delivery SDK. */
+  apiKey: string;
+  /** Content Delivery Token for the target environment. */
+  deliveryToken: string;
+  /** Environment name (e.g. `production`, `staging`). */
+  environment: string;
+  /**
+   * Stack region: `na`, `eu`, `au`, `azure-na`, `azure-eu`, `gcp-na`, or
+   * `gcp-eu`. The aliases `us`, `aws-na`, `aws-eu`, and `aws-au` are also
+   * accepted. Defaults to `na` when unset or empty. An unrecognized value
+   * throws at initialization.
+   */
+  region?: string;
+  /** Optional content branch name. */
+  branch?: string;
+  /** Preview Token, read lazily on first preview request. */
+  previewAccessToken?: string;
+  /** Whether to fetch draft content when the request is in editor mode. */
+  draftContentEnabled: boolean;
+}
+/**
+ * Contentstack CMS provider service.
+ * Uses a static singleton for delivery (read-only, safe across requests)
+ * and creates a fresh Stack instance per preview request because
+ * `livePreviewQuery()` mutates the internal config.
+ *
+ * Unlike Storyblok and Contentful, this class needs no tenant subclass
+ * today — `isPageComponent`/`isProductlistingpageComponent` check a fixed
+ * `seo` field shape rather than delegating to generated guards. The
+ * boilerplate still keeps a thin `service.ts` wrapper per tenant fork
+ * (constructed from env vars via `createCMSService()`), since that file is
+ * what `pnpm cms:sync` and future tenant customization would touch, even
+ * though it currently has no override to add.
+ *
+ * @see https://www.contentstack.com/docs/developers/sdks/content-delivery-sdk/typescript/get-started-with-typescript-delivery-sdk
+ */
+declare class ContentstackCMSService implements CMSProviderService {
+  private static deliveryStack;
+  readonly cspConfig: CMSCspConfig;
+  private readonly config;
+  private readonly draftContentEnabled;
+  private readonly context;
+  constructor(config: ContentstackCMSServiceConfig, context: StorefrontContext);
+  /**
+   * Builds editor data for the current request.
+   * Contentstack's Live Preview SDK runs client-side and needs its own
+   * access token, environment, branch, and region to connect.
+   *
+   * @param request Incoming request, used to detect editor mode
+   * @returns Editor data fields for Inertia page props, or undefined outside an editor session
+   */
+  getCMSEditorData(request: CMSRequestLike): CMSEditorData | undefined;
+  private getDeliveryStack;
+  private createPreviewStack;
+  /**
+   * Checks whether the current request originates from the Contentstack
+   * Live Preview / Visual Builder. Detects editor mode via the
+   * `live_preview` query parameter.
+   *
+   * @param request Incoming HTTP request
+   * @returns True when the request is from Contentstack's live preview
+   */
+  isEditorMode(request: CMSRequestLike): boolean;
+  /**
+   * Content-type UID and URL slug queried by `fetchPageData`.
+   * Override to look up a different content type or URL shape.
+   *
+   * @param slug Page slug to look up
+   * @returns Content-type UID and the `url` field value to match
+   */
+  protected buildPageQuery(slug: string): {
+    contentTypeUid: string;
+    url: string;
+  };
+  /**
+   * Runs a Contentstack entry query for the given content type and URL,
+   * returning the first matching entry. Shared by `fetchPageData` and
+   * `fetchListingPageData`; override `buildPageQuery`/`buildListingQuery`
+   * to change what gets queried, not this method.
+   *
+   * @param stack Delivery or preview stack
+   * @param contentTypeUid Content-type UID to query
+   * @param url URL field value to match
+   * @param locale Storefront locale code
+   * @returns First matching entry, or undefined when none match
+   */
+  private findEntry;
+  /**
+   * Retrieves CMS page content from Contentstack by slug.
+   * Uses the delivery singleton for normal requests and a fresh preview
+   * instance for live preview requests. Tags entries with editable-field
+   * metadata when the request is an active live preview session.
+   *
+   * @param slug Page slug to look up
+   * @param locale Storefront locale code
+   * @param useDraftContent Whether to fetch draft content instead of published content
+   * @param request Incoming request, used to read editor-specific query params
+   * @returns Contentstack page data
+   * @throws {CMSContentNotFoundError} When no entry matches the slug
+   */
+  private fetchRawPageData;
+  /**
+   * Retrieves CMS page data with application-level caching.
+   * Preview requests bypass the cache entirely.
+   *
+   * @param slug CMS slug
+   * @param locale Storefront locale code
+   * @param request Incoming request, used to detect editor mode and read editor-specific query params
+   * @returns Contentstack page data or undefined
+   */
+  fetchPageData(slug: string, locale: string, request: CMSRequestLike): Promise<CMSPagePayload | undefined>;
+  /**
+   * Content-type UID and URL slug queried by `fetchListingPageData`.
+   * Override to look up a different content type or URL shape.
+   *
+   * @param categoryId SCAYLE category ID
+   * @returns Content-type UID and the `url` field value to match
+   */
+  protected buildListingQuery(categoryId: number): {
+    contentTypeUid: string;
+    url: string;
+  };
+  /**
+   * Retrieves CMS content for a product listing page.
+   * Throws {@link CMSContentNotFoundError} when no entry matches the
+   * category; {@link fetchListingPageData} converts that into `undefined`
+   * for the caller.
+   *
+   * @param categoryId SCAYLE category ID
+   * @param locale Storefront locale code
+   * @param useDraftContent Whether to fetch draft content instead of published content
+   * @returns Contentstack listing page data
+   * @throws {CMSContentNotFoundError} When no entry matches the category
+   */
+  private fetchRawListingPageData;
+  /**
+   * Retrieves CMS content for a product listing page, with caching.
+   * Converts a missing entry into `undefined` rather than throwing, since
+   * missing PLP content is expected, not an error condition.
+   *
+   * @param categoryId SCAYLE category ID
+   * @param locale Storefront locale code
+   * @param request Incoming request, used to detect editor mode and read editor-specific query params
+   * @returns Contentstack listing page data or undefined
+   */
+  fetchListingPageData(categoryId: number, locale: string, request: CMSRequestLike): Promise<CMSPagePayload | undefined>;
+}
+/**
+ * CSP configuration for the Contentstack provider.
+ * Allows the Contentstack Visual Builder to embed the storefront in an
+ * iframe and the Live Preview SDK to communicate with the Contentstack API.
+ * Uses wildcard subdomains for region-agnostic support (EU, US, Azure, GCP).
+ */
+declare const cspConfig: CMSCspConfig;
+export { ContentstackCMSService, cspConfig };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/ContentstackCMSService.ts","../src/csp.ts"],"mappings":";;;YAkCmB;IACf;IACA;IACA;IACA;;;;;;;;UAqCa;;EAEf;;EAEA;;EAEA;;;;;;;EAOA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;cAmBW,kCAAkC;iBAC9B;WAEN,WAAW;mBAEH;mBAKA;mBAEA;EAEjB,YACE,QAAQ,8BACR,SAAS;;;;;;;;;EAoCX,iBAAiB,SAAS,iBAAiB;UAanC;UAsBA;;;;;;;;;EAsCR,aAAa,SAAS;;;;;;;;YAWZ,eAAe;IACvB;IACA;;;;;;;;;;;;;;UAiBY;;;;;;;;;;;;;;UAqCA;;;;;;;;;;EAyEd,cACE,cACA,gBACA,SAAS,iBACR,QAAQ;;;;;;;;YA6BD,kBAAkB;IAC1B;IACA;;;;;;;;;;;;;;UAoBY;;;;;;;;;;;EAsDd,qBACE,oBACA,gBACA,SAAS,iBACR,QAAQ;;;;;;;;cCneA,WAAW"}

package/dist/index.mjs

@@ -0,0 +1,204 @@
+import contentstack, { QueryOperation } from "@contentstack/delivery-sdk";
+import { getContentstackEndpoints, getRegionForString } from "@timbenniks/contentstack-endpoints";
+import { CMSContentNotFoundError, extractErrorStatus, wrapClientInit } from "@scayle/storefront/cms";
+import { createLogger } from "@scayle/storefront/shared";
+const cspConfig = {
+	isPreviewRequest: (req) => Boolean(req.query("live_preview")),
+	directives: {
+		"frame-ancestors": "'self' https://*.contentstack.com",
+		"script-src": "'self' 'unsafe-inline' https://*.contentstack.com",
+		"connect-src": "'self' https://*.contentstack.io https://*.contentstack.com"
+	}
+};
+const log = createLogger("cms");
+const CACHE_TTL_SECONDS = 300;
+function resolveRegion(region) {
+	const resolved = getRegionForString(region);
+	if (!resolved) throw new Error(`Contentstack CMS initialization failed: invalid region "${region}". Set CONTENTSTACK_CMS_REGION to one of: na, eu, au, azure-na, azure-eu, gcp-na, gcp-eu. The aliases "us", "aws-na", "aws-eu", and "aws-au" are also accepted. See https://www.contentstack.com/docs/developers/contentstack-regions/api-endpoints`);
+	return resolved;
+}
+function getEndpoints(region) {
+	return getContentstackEndpoints(resolveRegion(region), true);
+}
+var ContentstackCMSService = class ContentstackCMSService {
+	static deliveryStack;
+	cspConfig = cspConfig;
+	config;
+	draftContentEnabled;
+	context;
+	constructor(config, context) {
+		if (!config.apiKey) throw new Error("Contentstack CMS initialization failed: missing or empty API key. Check that CONTENTSTACK_CMS_STACK_API_KEY is set.");
+		if (!config.deliveryToken) throw new Error("Contentstack CMS initialization failed: missing or empty delivery token. Check that CONTENTSTACK_CMS_DELIVERY_TOKEN is set.");
+		if (!config.environment) throw new Error("Contentstack CMS initialization failed: missing or empty environment. Check that CONTENTSTACK_CMS_ENVIRONMENT is set.");
+		this.config = {
+			...config,
+			region: resolveRegion(config.region || "na")
+		};
+		this.draftContentEnabled = config.draftContentEnabled;
+		this.context = context;
+	}
+	getCMSEditorData(request) {
+		if (!this.isEditorMode(request)) return;
+		return {
+			accessToken: this.config.deliveryToken,
+			environment: this.config.environment,
+			branch: this.config.branch,
+			region: this.config.region
+		};
+	}
+	getDeliveryStack() {
+		if (ContentstackCMSService.deliveryStack) return ContentstackCMSService.deliveryStack;
+		const { apiKey, deliveryToken, environment, region } = this.config;
+		const endpoints = getEndpoints(region);
+		ContentstackCMSService.deliveryStack = wrapClientInit(() => contentstack.stack({
+			apiKey,
+			deliveryToken,
+			environment,
+			region,
+			host: endpoints.contentDelivery
+		}), "Contentstack delivery stack initialization failed. Check that CONTENTSTACK_CMS_STACK_API_KEY is a valid API key, CONTENTSTACK_CMS_DELIVERY_TOKEN is a valid delivery token, and CONTENTSTACK_CMS_ENVIRONMENT is a valid environment name");
+		return ContentstackCMSService.deliveryStack;
+	}
+	createPreviewStack() {
+		const { apiKey, deliveryToken, environment, region, previewAccessToken } = this.config;
+		if (!previewAccessToken) throw new Error("Contentstack CMS initialization failed: missing or empty preview token. Check that CONTENTSTACK_CMS_PREVIEW_ACCESS_TOKEN is set.");
+		const endpoints = getEndpoints(region);
+		return wrapClientInit(() => contentstack.stack({
+			apiKey,
+			deliveryToken,
+			environment,
+			region,
+			host: endpoints.contentDelivery,
+			live_preview: {
+				enable: true,
+				preview_token: previewAccessToken,
+				host: endpoints.preview
+			}
+		}), "Contentstack preview stack initialization failed. Check that CONTENTSTACK_CMS_STACK_API_KEY is a valid API key, CONTENTSTACK_CMS_DELIVERY_TOKEN is a valid delivery token, CONTENTSTACK_CMS_PREVIEW_ACCESS_TOKEN is a valid preview token, and CONTENTSTACK_CMS_ENVIRONMENT is a valid environment name");
+	}
+	isEditorMode(request) {
+		return Boolean(request.query("live_preview"));
+	}
+	buildPageQuery(slug) {
+		return {
+			contentTypeUid: "page-component",
+			url: `/${slug}`
+		};
+	}
+	async findEntry(stack, contentTypeUid, url, locale) {
+		return (await stack.contentType(contentTypeUid).entry().locale(locale.toLowerCase()).includeFallback().query().where("url", QueryOperation.EQUALS, url).addParams({
+			include_all: "true",
+			include_all_depth: "5",
+			include_dimension: "true"
+		}).limit(1).find()).entries?.at(0);
+	}
+	async fetchRawPageData(slug, locale, useDraftContent, request) {
+		const stack = useDraftContent ? this.createPreviewStack() : this.getDeliveryStack();
+		const { contentTypeUid, url } = this.buildPageQuery(slug);
+		const livePreview = useDraftContent && request.query("live_preview");
+		if (livePreview) stack.livePreviewQuery({
+			live_preview: livePreview,
+			content_type_uid: request.query("content_type_uid") ?? contentTypeUid
+		});
+		try {
+			const entry = await this.findEntry(stack, contentTypeUid, url, locale);
+			if (!entry) throw new CMSContentNotFoundError("Contentstack content not found", { details: {
+				slug,
+				locale,
+				contentTypeUid,
+				url
+			} });
+			if (livePreview) try {
+				contentstack.Utils.addEditableTags(entry, contentTypeUid, true, locale.toLowerCase());
+			} catch {}
+			return { entry };
+		} catch (error) {
+			if (error instanceof CMSContentNotFoundError) throw error;
+			if (extractErrorStatus(error) === 404) throw new CMSContentNotFoundError("Contentstack content not found", {
+				cause: error,
+				details: {
+					slug,
+					locale,
+					contentTypeUid,
+					url
+				}
+			});
+			const cause = error instanceof Error ? error : new Error(String(error));
+			throw new Error(`Contentstack API request failed (slug: "${slug}", locale: "${locale}", content-type: "${contentTypeUid}"): ${cause.message}`, { cause });
+		}
+	}
+	async fetchPageData(slug, locale, request) {
+		const useDraftContent = this.isEditorMode(request) && this.draftContentEnabled;
+		if (useDraftContent) {
+			log.debug({
+				message: "Bypassing CMS cache in preview mode",
+				slug,
+				locale
+			});
+			return await this.fetchRawPageData(slug, locale, useDraftContent, request);
+		}
+		return await this.context.cache.getOrSet(`cms:contentstack:page:${slug}:${locale}`, () => this.fetchRawPageData(slug, locale, useDraftContent, request), CACHE_TTL_SECONDS);
+	}
+	buildListingQuery(categoryId) {
+		return {
+			contentTypeUid: "productlistingpage-component",
+			url: `/c/c-${categoryId}`
+		};
+	}
+	async fetchRawListingPageData(categoryId, locale, useDraftContent) {
+		const stack = useDraftContent ? this.createPreviewStack() : this.getDeliveryStack();
+		const { contentTypeUid, url } = this.buildListingQuery(categoryId);
+		try {
+			const entry = await this.findEntry(stack, contentTypeUid, url, locale);
+			if (!entry) throw new CMSContentNotFoundError("Contentstack listing content not found", { details: {
+				categoryId,
+				slug: url,
+				locale,
+				contentTypeUid
+			} });
+			return { entry };
+		} catch (error) {
+			if (error instanceof CMSContentNotFoundError) throw error;
+			if (extractErrorStatus(error) === 404) throw new CMSContentNotFoundError("Contentstack listing content not found", {
+				cause: error,
+				details: {
+					categoryId,
+					slug: url,
+					locale,
+					contentTypeUid
+				}
+			});
+			const cause = error instanceof Error ? error : new Error(String(error));
+			throw new Error(`Contentstack API request failed (category: ${categoryId}, url: "${url}", locale: "${locale}", content-type: "${contentTypeUid}"): ${cause.message}`, { cause });
+		}
+	}
+	async fetchListingPageData(categoryId, locale, request) {
+		const useDraftContent = this.isEditorMode(request) && this.draftContentEnabled;
+		const fetchListing = async () => {
+			try {
+				return await this.fetchRawListingPageData(categoryId, locale, useDraftContent);
+			} catch (error) {
+				if (error instanceof CMSContentNotFoundError) return;
+				log.error({
+					message: "Failed to fetch CMS listing page data",
+					err: error instanceof Error ? error : new Error(String(error)),
+					categoryId,
+					locale
+				});
+				throw error;
+			}
+		};
+		if (useDraftContent) {
+			log.debug({
+				message: "Bypassing CMS PLP cache in preview mode",
+				categoryId,
+				locale
+			});
+			return await fetchListing();
+		}
+		return await this.context.cache.getOrSet(`cms:contentstack:plp:${categoryId}:${locale}`, () => fetchListing(), CACHE_TTL_SECONDS);
+	}
+};
+export { ContentstackCMSService, cspConfig };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/csp.ts","../src/ContentstackCMSService.ts"],"sourcesContent":["import type { CMSCspConfig } from '@scayle/storefront/cms'\n\n/**\n * CSP configuration for the Contentstack provider.\n * Allows the Contentstack Visual Builder to embed the storefront in an\n * iframe and the Live Preview SDK to communicate with the Contentstack API.\n * Uses wildcard subdomains for region-agnostic support (EU, US, Azure, GCP).\n */\nexport const cspConfig: CMSCspConfig = {\n  isPreviewRequest: (req) => Boolean(req.query('live_preview')),\n  directives: {\n    'frame-ancestors': \"'self' https://*.contentstack.com\",\n    'script-src': \"'self' 'unsafe-inline' https://*.contentstack.com\",\n    'connect-src':\n      \"'self' https://*.contentstack.io https://*.contentstack.com\",\n  },\n}\n","import contentstack, { QueryOperation } from '@contentstack/delivery-sdk'\nimport type { Stack } from '@contentstack/delivery-sdk'\nimport {\n  getContentstackEndpoints,\n  getRegionForString,\n} from '@timbenniks/contentstack-endpoints'\nimport {\n  CMSContentNotFoundError,\n  extractErrorStatus,\n  wrapClientInit,\n} from '@scayle/storefront/cms'\nimport type {\n  CMSCspConfig,\n  CMSEditorData,\n  CMSPagePayload,\n  CMSProviderService,\n  CMSRequestLike,\n} from '@scayle/storefront/cms'\nimport { createLogger } from '@scayle/storefront/shared'\nimport type { StorefrontContext } from '@scayle/storefront/types'\nimport { cspConfig } from './csp'\n\nconst log = createLogger('cms')\n\n/** Cache TTL for published CMS content: 5 minutes. */\nconst CACHE_TTL_SECONDS = 5 * 60\n\ndeclare module '@scayle/storefront/cms' {\n  /**\n   * Fields added by `ContentstackCMSService.getCMSEditorData()` for the\n   * client-side Live Preview SDK. A tenant project can layer further fields\n   * onto `CMSEditorData` with its own `declare module` block; TypeScript\n   * merges augmentations from every file in the program.\n   */\n  export interface CMSEditorData {\n    accessToken?: string\n    environment?: string\n    branch?: string\n    region?: string\n  }\n}\n\n/**\n * Resolves a configured region string to a Contentstack region identifier.\n *\n * `getContentstackEndpoints` returns an empty object rather than throwing for an\n * unknown region, which would leave `host` undefined and let the Delivery SDK\n * silently fall back to its North America default. Resolving up front turns a\n * misconfigured region into a startup error instead of wrong-region content.\n *\n * @param region Configured region value\n * @returns Canonical region identifier\n * @throws Error when the region is not a recognized Contentstack region\n */\nfunction resolveRegion(region: string): string {\n  const resolved = getRegionForString(region)\n\n  if (!resolved) {\n    throw new Error(\n      `Contentstack CMS initialization failed: invalid region \"${region}\". Set CONTENTSTACK_CMS_REGION to one of: na, eu, au, azure-na, azure-eu, gcp-na, gcp-eu. The aliases \"us\", \"aws-na\", \"aws-eu\", and \"aws-au\" are also accepted. See https://www.contentstack.com/docs/developers/contentstack-regions/api-endpoints`,\n    )\n  }\n\n  return resolved\n}\n\nfunction getEndpoints(region: string) {\n  return getContentstackEndpoints(resolveRegion(region), true)\n}\n\n/**\n * Configuration accepted by {@link ContentstackCMSService}'s constructor.\n * The boilerplate reads these from environment variables and passes plain\n * values in, so this package never touches `process.env` directly.\n */\nexport interface ContentstackCMSServiceConfig {\n  /** Stack API key (Stack > Settings > Tokens). Used as `apiKey` in the Delivery SDK. */\n  apiKey: string\n  /** Content Delivery Token for the target environment. */\n  deliveryToken: string\n  /** Environment name (e.g. `production`, `staging`). */\n  environment: string\n  /**\n   * Stack region: `na`, `eu`, `au`, `azure-na`, `azure-eu`, `gcp-na`, or\n   * `gcp-eu`. The aliases `us`, `aws-na`, `aws-eu`, and `aws-au` are also\n   * accepted. Defaults to `na` when unset or empty. An unrecognized value\n   * throws at initialization.\n   */\n  region?: string\n  /** Optional content branch name. */\n  branch?: string\n  /** Preview Token, read lazily on first preview request. */\n  previewAccessToken?: string\n  /** Whether to fetch draft content when the request is in editor mode. */\n  draftContentEnabled: boolean\n}\n\n/**\n * Contentstack CMS provider service.\n * Uses a static singleton for delivery (read-only, safe across requests)\n * and creates a fresh Stack instance per preview request because\n * `livePreviewQuery()` mutates the internal config.\n *\n * Unlike Storyblok and Contentful, this class needs no tenant subclass\n * today — `isPageComponent`/`isProductlistingpageComponent` check a fixed\n * `seo` field shape rather than delegating to generated guards. The\n * boilerplate still keeps a thin `service.ts` wrapper per tenant fork\n * (constructed from env vars via `createCMSService()`), since that file is\n * what `pnpm cms:sync` and future tenant customization would touch, even\n * though it currently has no override to add.\n *\n * @see https://www.contentstack.com/docs/developers/sdks/content-delivery-sdk/typescript/get-started-with-typescript-delivery-sdk\n */\nexport class ContentstackCMSService implements CMSProviderService {\n  private static deliveryStack: Stack | undefined\n\n  readonly cspConfig: CMSCspConfig = cspConfig\n\n  private readonly config: Required<\n    Omit<ContentstackCMSServiceConfig, 'branch' | 'previewAccessToken'>\n  > &\n    Pick<ContentstackCMSServiceConfig, 'branch' | 'previewAccessToken'>\n\n  private readonly draftContentEnabled: boolean\n\n  private readonly context: StorefrontContext\n\n  constructor(\n    config: ContentstackCMSServiceConfig,\n    context: StorefrontContext,\n  ) {\n    if (!config.apiKey) {\n      throw new Error(\n        'Contentstack CMS initialization failed: missing or empty API key. Check that CONTENTSTACK_CMS_STACK_API_KEY is set.',\n      )\n    }\n\n    if (!config.deliveryToken) {\n      throw new Error(\n        'Contentstack CMS initialization failed: missing or empty delivery token. Check that CONTENTSTACK_CMS_DELIVERY_TOKEN is set.',\n      )\n    }\n\n    if (!config.environment) {\n      throw new Error(\n        'Contentstack CMS initialization failed: missing or empty environment. Check that CONTENTSTACK_CMS_ENVIRONMENT is set.',\n      )\n    }\n\n    // `||` not `??`: a blanked `CONTENTSTACK_CMS_REGION=` arrives as an empty\n    // string, which is \"not set\" rather than a typo. This matches the `region ||\n    // 'na'` in the setup CLI and `${CONTENTSTACK_CMS_REGION:-na}` in sync-cms.sh.\n    this.config = { ...config, region: resolveRegion(config.region || 'na') }\n    this.draftContentEnabled = config.draftContentEnabled\n    this.context = context\n  }\n\n  /**\n   * Builds editor data for the current request.\n   * Contentstack's Live Preview SDK runs client-side and needs its own\n   * access token, environment, branch, and region to connect.\n   *\n   * @param request Incoming request, used to detect editor mode\n   * @returns Editor data fields for Inertia page props, or undefined outside an editor session\n   */\n  getCMSEditorData(request: CMSRequestLike): CMSEditorData | undefined {\n    if (!this.isEditorMode(request)) {\n      return undefined\n    }\n\n    return {\n      accessToken: this.config.deliveryToken,\n      environment: this.config.environment,\n      branch: this.config.branch,\n      region: this.config.region,\n    }\n  }\n\n  private getDeliveryStack(): Stack {\n    if (ContentstackCMSService.deliveryStack) {\n      return ContentstackCMSService.deliveryStack\n    }\n\n    const { apiKey, deliveryToken, environment, region } = this.config\n    const endpoints = getEndpoints(region)\n\n    ContentstackCMSService.deliveryStack = wrapClientInit(\n      () =>\n        contentstack.stack({\n          apiKey,\n          deliveryToken,\n          environment,\n          region,\n          host: endpoints.contentDelivery,\n        }),\n      'Contentstack delivery stack initialization failed. Check that CONTENTSTACK_CMS_STACK_API_KEY is a valid API key, CONTENTSTACK_CMS_DELIVERY_TOKEN is a valid delivery token, and CONTENTSTACK_CMS_ENVIRONMENT is a valid environment name',\n    )\n    return ContentstackCMSService.deliveryStack\n  }\n\n  private createPreviewStack(): Stack {\n    const { apiKey, deliveryToken, environment, region, previewAccessToken } =\n      this.config\n\n    if (!previewAccessToken) {\n      throw new Error(\n        'Contentstack CMS initialization failed: missing or empty preview token. Check that CONTENTSTACK_CMS_PREVIEW_ACCESS_TOKEN is set.',\n      )\n    }\n\n    const endpoints = getEndpoints(region)\n\n    return wrapClientInit(\n      () =>\n        contentstack.stack({\n          apiKey,\n          deliveryToken,\n          environment,\n          region,\n          host: endpoints.contentDelivery,\n          live_preview: {\n            enable: true,\n            preview_token: previewAccessToken,\n            host: endpoints.preview,\n          },\n        }),\n      'Contentstack preview stack initialization failed. Check that CONTENTSTACK_CMS_STACK_API_KEY is a valid API key, CONTENTSTACK_CMS_DELIVERY_TOKEN is a valid delivery token, CONTENTSTACK_CMS_PREVIEW_ACCESS_TOKEN is a valid preview token, and CONTENTSTACK_CMS_ENVIRONMENT is a valid environment name',\n    )\n  }\n\n  /**\n   * Checks whether the current request originates from the Contentstack\n   * Live Preview / Visual Builder. Detects editor mode via the\n   * `live_preview` query parameter.\n   *\n   * @param request Incoming HTTP request\n   * @returns True when the request is from Contentstack's live preview\n   */\n  isEditorMode(request: CMSRequestLike): boolean {\n    return Boolean(request.query('live_preview'))\n  }\n\n  /**\n   * Content-type UID and URL slug queried by `fetchPageData`.\n   * Override to look up a different content type or URL shape.\n   *\n   * @param slug Page slug to look up\n   * @returns Content-type UID and the `url` field value to match\n   */\n  protected buildPageQuery(slug: string): {\n    contentTypeUid: string\n    url: string\n  } {\n    return { contentTypeUid: 'page-component', url: `/${slug}` }\n  }\n\n  /**\n   * Runs a Contentstack entry query for the given content type and URL,\n   * returning the first matching entry. Shared by `fetchPageData` and\n   * `fetchListingPageData`; override `buildPageQuery`/`buildListingQuery`\n   * to change what gets queried, not this method.\n   *\n   * @param stack Delivery or preview stack\n   * @param contentTypeUid Content-type UID to query\n   * @param url URL field value to match\n   * @param locale Storefront locale code\n   * @returns First matching entry, or undefined when none match\n   */\n  private async findEntry(\n    stack: Stack,\n    contentTypeUid: string,\n    url: string,\n    locale: string,\n  ): Promise<unknown | undefined> {\n    const result = await stack\n      .contentType(contentTypeUid)\n      .entry()\n      .locale(locale.toLowerCase())\n      .includeFallback()\n      .query()\n      .where('url', QueryOperation.EQUALS, url)\n      .addParams({\n        include_all: 'true',\n        include_all_depth: '5',\n        include_dimension: 'true',\n      })\n      .limit(1)\n      .find()\n\n    return result.entries?.at(0)\n  }\n\n  /**\n   * Retrieves CMS page content from Contentstack by slug.\n   * Uses the delivery singleton for normal requests and a fresh preview\n   * instance for live preview requests. Tags entries with editable-field\n   * metadata when the request is an active live preview session.\n   *\n   * @param slug Page slug to look up\n   * @param locale Storefront locale code\n   * @param useDraftContent Whether to fetch draft content instead of published content\n   * @param request Incoming request, used to read editor-specific query params\n   * @returns Contentstack page data\n   * @throws {CMSContentNotFoundError} When no entry matches the slug\n   */\n  private async fetchRawPageData(\n    slug: string,\n    locale: string,\n    useDraftContent: boolean,\n    request: CMSRequestLike,\n  ): Promise<CMSPagePayload | undefined> {\n    const stack = useDraftContent\n      ? this.createPreviewStack()\n      : this.getDeliveryStack()\n    const { contentTypeUid, url } = this.buildPageQuery(slug)\n    const livePreview = useDraftContent && request.query('live_preview')\n\n    if (livePreview) {\n      stack.livePreviewQuery({\n        live_preview: livePreview,\n        content_type_uid: request.query('content_type_uid') ?? contentTypeUid,\n      })\n    }\n\n    try {\n      const entry = await this.findEntry(stack, contentTypeUid, url, locale)\n\n      if (!entry) {\n        throw new CMSContentNotFoundError('Contentstack content not found', {\n          details: { slug, locale, contentTypeUid, url },\n        })\n      }\n\n      if (livePreview) {\n        try {\n          contentstack.Utils.addEditableTags(\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            entry as any,\n            contentTypeUid,\n            true,\n            locale.toLowerCase(),\n          )\n        } catch {\n          // Editable tags only add inline edit markers for the Visual\n          // Builder; a tagging failure must not fail the page request itself.\n        }\n      }\n\n      return { entry }\n    } catch (error) {\n      if (error instanceof CMSContentNotFoundError) {\n        throw error\n      }\n\n      if (extractErrorStatus(error) === 404) {\n        throw new CMSContentNotFoundError('Contentstack content not found', {\n          cause: error,\n          details: { slug, locale, contentTypeUid, url },\n        })\n      }\n\n      const cause = error instanceof Error ? error : new Error(String(error))\n      throw new Error(\n        `Contentstack API request failed (slug: \"${slug}\", locale: \"${locale}\", content-type: \"${contentTypeUid}\"): ${cause.message}`,\n        { cause },\n      )\n    }\n  }\n\n  /**\n   * Retrieves CMS page data with application-level caching.\n   * Preview requests bypass the cache entirely.\n   *\n   * @param slug CMS slug\n   * @param locale Storefront locale code\n   * @param request Incoming request, used to detect editor mode and read editor-specific query params\n   * @returns Contentstack page data or undefined\n   */\n  async fetchPageData(\n    slug: string,\n    locale: string,\n    request: CMSRequestLike,\n  ): Promise<CMSPagePayload | undefined> {\n    const useDraftContent =\n      this.isEditorMode(request) && this.draftContentEnabled\n\n    if (useDraftContent) {\n      log.debug({\n        message: 'Bypassing CMS cache in preview mode',\n        slug,\n        locale,\n      })\n      return await this.fetchRawPageData(slug, locale, useDraftContent, request)\n    }\n\n    return await this.context.cache.getOrSet(\n      `cms:contentstack:page:${slug}:${locale}`,\n      // Cast required: StorageValue excludes undefined, but the fetch can return undefined for missing content\n      () =>\n        this.fetchRawPageData(slug, locale, useDraftContent, request) as never,\n      CACHE_TTL_SECONDS,\n    )\n  }\n\n  /**\n   * Content-type UID and URL slug queried by `fetchListingPageData`.\n   * Override to look up a different content type or URL shape.\n   *\n   * @param categoryId SCAYLE category ID\n   * @returns Content-type UID and the `url` field value to match\n   */\n  protected buildListingQuery(categoryId: number): {\n    contentTypeUid: string\n    url: string\n  } {\n    return {\n      contentTypeUid: 'productlistingpage-component',\n      url: `/c/c-${categoryId}`,\n    }\n  }\n\n  /**\n   * Retrieves CMS content for a product listing page.\n   * Throws {@link CMSContentNotFoundError} when no entry matches the\n   * category; {@link fetchListingPageData} converts that into `undefined`\n   * for the caller.\n   *\n   * @param categoryId SCAYLE category ID\n   * @param locale Storefront locale code\n   * @param useDraftContent Whether to fetch draft content instead of published content\n   * @returns Contentstack listing page data\n   * @throws {CMSContentNotFoundError} When no entry matches the category\n   */\n  private async fetchRawListingPageData(\n    categoryId: number,\n    locale: string,\n    useDraftContent: boolean,\n  ): Promise<CMSPagePayload | undefined> {\n    const stack = useDraftContent\n      ? this.createPreviewStack()\n      : this.getDeliveryStack()\n    const { contentTypeUid, url } = this.buildListingQuery(categoryId)\n\n    try {\n      const entry = await this.findEntry(stack, contentTypeUid, url, locale)\n\n      if (!entry) {\n        throw new CMSContentNotFoundError(\n          'Contentstack listing content not found',\n          { details: { categoryId, slug: url, locale, contentTypeUid } },\n        )\n      }\n\n      return { entry }\n    } catch (error) {\n      if (error instanceof CMSContentNotFoundError) {\n        throw error\n      }\n\n      if (extractErrorStatus(error) === 404) {\n        throw new CMSContentNotFoundError(\n          'Contentstack listing content not found',\n          {\n            cause: error,\n            details: { categoryId, slug: url, locale, contentTypeUid },\n          },\n        )\n      }\n\n      const cause = error instanceof Error ? error : new Error(String(error))\n      throw new Error(\n        `Contentstack API request failed (category: ${categoryId}, url: \"${url}\", locale: \"${locale}\", content-type: \"${contentTypeUid}\"): ${cause.message}`,\n        { cause },\n      )\n    }\n  }\n\n  /**\n   * Retrieves CMS content for a product listing page, with caching.\n   * Converts a missing entry into `undefined` rather than throwing, since\n   * missing PLP content is expected, not an error condition.\n   *\n   * @param categoryId SCAYLE category ID\n   * @param locale Storefront locale code\n   * @param request Incoming request, used to detect editor mode and read editor-specific query params\n   * @returns Contentstack listing page data or undefined\n   */\n  async fetchListingPageData(\n    categoryId: number,\n    locale: string,\n    request: CMSRequestLike,\n  ): Promise<CMSPagePayload | undefined> {\n    const useDraftContent =\n      this.isEditorMode(request) && this.draftContentEnabled\n    const fetchListing = async () => {\n      try {\n        return await this.fetchRawListingPageData(\n          categoryId,\n          locale,\n          useDraftContent,\n        )\n      } catch (error) {\n        if (error instanceof CMSContentNotFoundError) {\n          return undefined\n        }\n\n        log.error({\n          message: 'Failed to fetch CMS listing page data',\n          err: error instanceof Error ? error : new Error(String(error)),\n          categoryId,\n          locale,\n        })\n\n        throw error\n      }\n    }\n\n    if (useDraftContent) {\n      log.debug({\n        message: 'Bypassing CMS PLP cache in preview mode',\n        categoryId,\n        locale,\n      })\n      return await fetchListing()\n    }\n\n    return await this.context.cache.getOrSet(\n      `cms:contentstack:plp:${categoryId}:${locale}`,\n      // Cast required: StorageValue excludes undefined, but the fetch can return undefined for missing content\n      () => fetchListing() as never,\n      CACHE_TTL_SECONDS,\n    )\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@scayle/storefront-cms-contentstack",
+  "version": "0.2.0-alpha.0",
+  "description": "Contentstack CMS provider integration for the SCAYLE Storefront Application V3",
+  "author": "SCAYLE Commerce Engine",
+  "license": "MIT",
+  "type": "module",
+  "private": false,
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "files": [
+    "CHANGELOG.md",
+    "dist"
+  ],
+  "engines": {
+    "node": ">= 24.0.0"
+  },
+  "peerDependencies": {
+    "@contentstack/delivery-sdk": "^5.4.0",
+    "@timbenniks/contentstack-endpoints": "^3.0.2",
+    "@scayle/storefront": "1.0.0-alpha.2"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@contentstack/delivery-sdk": "^5.4.0",
+    "@timbenniks/contentstack-endpoints": "^3.0.2",
+    "@types/node": "^24",
+    "@vitest/coverage-v8": "4.1.10",
+    "eslint": "10.8.1",
+    "eslint-formatter-gitlab": "7.2.0",
+    "publint": "0.3.23",
+    "typescript": "6.0.3",
+    "obuild": "0.4.38",
+    "vitest": "4.1.10",
+    "@scayle/eslint-config-storefront": "4.8.3-alpha.0",
+    "@scayle/storefront": "1.0.0-alpha.2",
+    "@scayle/vitest-config-storefront": "1.0.0"
+  },
+  "scripts": {
+    "build": "obuild",
+    "lint": "eslint .",
+    "lint:ci": "eslint . --format gitlab",
+    "lint:fix": "eslint . --fix",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "package:lint": "publint",
+    "verify-packaging": "attw --pack . --profile esm-only"
+  }
+}