@laioutr/app-shopware 0.17.0 → 0.19.0

package/README.md

@@ -17,8 +17,9 @@ See [laioutr.com](https://laioutr.com) for more information about Laioutr.
 
 - Products, categories, menus, reviews and search served through Laioutr's Orchestr layer, mapped
   onto the canonical entity model — so storefront components stay backend-agnostic
-- Cart as a first-class entity: add, update and remove items, with server-held Shopware context
-  tokens that never reach the browser
+- Cart as a first-class entity: add, update and remove items, redeem discount codes, and read back
+  the shop's automatic cart discounts — with server-held Shopware context tokens that never reach
+  the browser
 - Embedded checkout — the Shopware storefront's own checkout rendered in-page, with a same-origin
   session handoff so the visitor is never bounced to another domain
 - Auth bridge: a storefront login or logout inside the embedded checkout propagates back into the

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@laioutr/app-shopware",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "configKey": "@laioutr/app-shopware",
   "builder": {
     "@nuxt/module-builder": "1.0.1",

package/dist/module.mjs

@@ -4,7 +4,7 @@ import { CHECKOUT_ENDPOINT_PATH, ADOPT_SESSION_ENDPOINT_PATH, ORDER_HANDOFF_ENDP
 import { registerLaioutrApp } from '@laioutr-core/kit';
 
 const name = "@laioutr/app-shopware";
-const version = "0.17.0";
+const version = "0.19.0";
 
 const module$1 = defineNuxtModule({
   meta: {

package/dist/runtime/server/composable/useGetProductParentId.js

@@ -1,12 +1,13 @@
-import { useEvent, useUserlandCache } from "#imports";
+import { useUserlandCache } from "#imports";
 const useProductParentIdCache = () => useUserlandCache("shopware/product-parent-id");
 const PRODUCT_PARENT_ID_CACHE_TTL = 60 * 60 * 24 * 7;
+const entryOptions = { maxAge: PRODUCT_PARENT_ID_CACHE_TTL };
 export const useGetProductParentId = (storefrontClient) => {
   const cache = useProductParentIdCache();
   return async (id) => {
-    const cachedParentId = await cache.getItem(id);
-    if (cachedParentId) {
-      return cachedParentId;
+    const cached = await cache.readOne(id, entryOptions);
+    if (cached && !cached.absent) {
+      return cached.value;
     }
     try {
       const response = await storefrontClient.invoke("readProduct post /product", {
@@ -17,7 +18,7 @@ export const useGetProductParentId = (storefrontClient) => {
       });
       const parentId = response.data.elements?.[0]?.parentId;
       if (parentId) {
-        cache.setItem(id, parentId, { ttl: PRODUCT_PARENT_ID_CACHE_TTL });
+        cache.writeOne(id, parentId, entryOptions);
         return parentId;
       }
       return void 0;
@@ -27,15 +28,11 @@ export const useGetProductParentId = (storefrontClient) => {
   };
 };
 export const cacheProductParentIds = (productIdsToParentIds) => {
-  const event = useEvent();
-  const cache = useProductParentIdCache();
-  event.waitUntil(
-    cache.setItems(
-      productIdsToParentIds.map(([productId, parentId]) => ({
-        key: productId,
-        value: parentId
-      })),
-      { ttl: PRODUCT_PARENT_ID_CACHE_TTL }
-    )
+  useProductParentIdCache().write(
+    productIdsToParentIds.map(([productId, parentId]) => ({
+      key: productId,
+      value: parentId,
+      options: entryOptions
+    }))
   );
 };

package/dist/runtime/server/orchestr/auth/login-oauth.action.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Send a visitor asking for their account to Shopware's own login page. Shopware authenticates
+ * with credentials rather than an OAuth handshake, so this answers the union's `account` arm and
+ * the storefront navigates there.
+ *
+ * `returnTo` is dropped: Shopware's login redirect takes one of its own route names, not a URL,
+ * so a laioutr path cannot travel through it.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/auth/login-oauth.action.js

@@ -0,0 +1,13 @@
+import { useRuntimeConfig } from "#imports";
+import { AuthLoginOauthAction } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareAction } from "../../middleware/defineShopware.js";
+export default defineShopwareAction(AuthLoginOauthAction, async () => {
+  const { storefrontUrl } = useRuntimeConfig()["@laioutr/app-shopware"];
+  if (!storefrontUrl) {
+    throw new Error("storefrontUrl is not configured, so there is no Shopware login page to send the customer to");
+  }
+  return {
+    type: "account",
+    link: { type: "url", href: new URL("/account/login", storefrontUrl).toString() }
+  };
+});

package/dist/runtime/server/orchestr/cart/add-item.action.js

@@ -1,11 +1,16 @@
 import { CartAddItemsAction } from "@laioutr-core/canonical-types/ecommerce";
 import { defineShopwareAction } from "../../middleware/defineShopware.js";
-import { handleCartMutationErrors } from "../../shopware-helper/cartErrors.js";
+import { handleCartMutationErrors, takeDiscountCodeErrors } from "../../shopware-helper/cartErrors.js";
 import { persistContextToken } from "../../shopware-helper/persistContextToken.js";
 export default defineShopwareAction(CartAddItemsAction, async ({ event, context, input }) => {
   const { storefrontClient } = context;
+  let persistedToken;
+  const persistToken = async (token) => {
+    if (!token || token === persistedToken) return;
+    persistedToken = token;
+    await persistContextToken(event, token);
+  };
   const products = input.filter((i) => i.type === "product");
-  const skuItems = input.filter((i) => i.type === "sku");
   if (products.length > 0) {
     const cart = await storefrontClient.invoke("addLineItem post /checkout/cart/line-item", {
       body: {
@@ -23,24 +28,44 @@ export default defineShopwareAction(CartAddItemsAction, async ({ event, context,
         }))
       }
     });
-    await persistContextToken(event, cart.data.token);
+    await persistToken(cart.data.token);
     handleCartMutationErrors(cart.data.errors);
   }
-  return {
-    items: [
-      ...products.map((product) => ({
+  const redeemDiscountCode = async (code) => {
+    const cart = await storefrontClient.invoke("addLineItem post /checkout/cart/line-item", {
+      body: { items: [{ type: "promotion", referencedId: code }] }
+    });
+    await persistToken(cart.data.token);
+    const { rejections, rest } = takeDiscountCodeErrors(cart.data.errors);
+    handleCartMutationErrors(rest);
+    const applied = (cart.data.lineItems ?? []).some((li) => li.type === "promotion" && li.referencedId === code);
+    if (applied) return { status: "added", quantity: 1 };
+    const [rejection] = rejections;
+    const key = rejection?.messageKey ?? rejection?.key;
+    return {
+      status: "rejected",
+      reason: key === "promotion-not-found" || key === void 0 ? "not-found" : key,
+      reasonLabel: rejection?.message
+    };
+  };
+  const items = [];
+  for (const item of input) {
+    if (item.type === "product") {
+      items.push({
         status: "added",
-        productId: product.productId,
-        variantId: product.variantId,
-        quantity: product.quantity
-      })),
-      // SKU resolution is not implemented for Shopware yet — report the rows
-      // as rejected instead of dropping them silently.
-      ...skuItems.map((item) => ({
+        productId: item.productId,
+        variantId: item.variantId,
+        quantity: item.quantity
+      });
+    } else if (item.type === "discount-code") {
+      items.push(await redeemDiscountCode(item.code));
+    } else {
+      items.push({
         status: "rejected",
-        sku: item.sku,
+        ...item.type === "sku" ? { sku: item.sku } : {},
         reason: "not-supported"
-      }))
-    ]
-  };
+      });
+    }
+  }
+  return { items };
 });

package/dist/runtime/server/orchestr/cart/cart-items.link.js

@@ -1,10 +1,11 @@
 import { CartItemsLink } from "@laioutr-core/canonical-types/ecommerce";
 import { cartFragmentToken } from "../../const/passthroughTokens.js";
 import { defineShopwareLink } from "../../middleware/defineShopware.js";
+import { isSupportedCartLineItem } from "../../shopware-helper/cartMapper.js";
 import { getCart } from "../../shopware-helper/getCart.js";
 export default defineShopwareLink(CartItemsLink, async ({ context, passthrough }) => {
   const cart = passthrough.get(cartFragmentToken) ?? await getCart(context.storefrontClient);
   passthrough.set(cartFragmentToken, cart);
-  const targetIds = (cart.lineItems ?? []).filter((li) => li.type === "product").map((li) => li.id);
+  const targetIds = (cart.lineItems ?? []).filter(isSupportedCartLineItem).map((li) => li.id);
   return { links: [{ sourceId: cart.token ?? "", targetIds }] };
 });

package/dist/runtime/server/orchestr/cart-item/base.resolver.js

@@ -7,7 +7,7 @@ import {
 } from "@laioutr-core/canonical-types/entity/cart-item";
 import { cartFragmentToken } from "../../const/passthroughTokens.js";
 import { defineShopwareComponentResolver } from "../../middleware/defineShopware.js";
-import { mapCartItem } from "../../shopware-helper/cartMapper.js";
+import { isSupportedCartLineItem, mapCartItem, mapDiscountItem } from "../../shopware-helper/cartMapper.js";
 import { getCart } from "../../shopware-helper/getCart.js";
 export default defineShopwareComponentResolver({
   entityType: "CartItem",
@@ -17,8 +17,8 @@ export default defineShopwareComponentResolver({
     const cart = passthrough.get(cartFragmentToken) ?? await getCart(context.storefrontClient);
     passthrough.set(cartFragmentToken, cart);
     const lineItemsById = new Map((cart.lineItems ?? []).map((li) => [li.id, li]));
-    const entities = entityIds.map((id) => lineItemsById.get(id)).filter((li) => !!li && li.type === "product").map((li) => {
-      const mapped = mapCartItem(li, context.swCurrency);
+    const entities = entityIds.map((id) => lineItemsById.get(id)).filter((li) => !!li && isSupportedCartLineItem(li)).map((li) => {
+      const mapped = li.type === "promotion" ? mapDiscountItem(li, context.swCurrency) : mapCartItem(li, context.swCurrency);
       return $entity({
         id: li.id,
         base: () => mapped.base,

package/dist/runtime/server/orchestr/customer/get-current.action.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read the customer behind the request's context token. Shopware answers `403` when the token
+ * belongs to a guest context, which is the signal callers use to tell a session from none.
+ *
+ * `addresses` stays empty: Shopware returns addresses only as an association, and each one needs
+ * its `countryId` resolved to the ISO code `MailingAddress` requires. Nothing reads them yet, so
+ * the lookup is not made — extend this handler before relying on the field.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/customer/get-current.action.js

@@ -0,0 +1,22 @@
+import { CustomerGetCurrentAction, UnauthenticatedError } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareAction } from "../../middleware/defineShopware.js";
+export default defineShopwareAction(CustomerGetCurrentAction, async ({ context }) => {
+  let customer;
+  try {
+    customer = await context.storefrontClient.invoke("readCustomer post /account/customer", {});
+  } catch {
+    throw new UnauthenticatedError();
+  }
+  const firstName = customer.firstName ?? "";
+  const lastName = customer.lastName ?? "";
+  const displayName = `${firstName} ${lastName}`.trim();
+  return {
+    customer: {
+      id: customer.id,
+      email: customer.email,
+      displayName: displayName || (customer.email ?? ""),
+      person: { firstName, lastName, salutation: customer.salutation?.salutationKey, title: customer.title ?? void 0 },
+      addresses: []
+    }
+  };
+});

package/dist/runtime/server/orchestr/menu/byAlias.template.js

@@ -2,7 +2,7 @@ import { MenuByAliasQuery } from "@laioutr-core/canonical-types/ecommerce";
 import { defineShopwareQueryTemplateProvider } from "../../middleware/defineShopware.js";
 export default defineShopwareQueryTemplateProvider({
   for: MenuByAliasQuery,
-  run: async ({ input, context }) => [
+  run: async () => [
     {
       input: {
         alias: "main-navigation"

package/dist/runtime/server/orchestr/product/reviews.link.js

@@ -1,8 +1,17 @@
 import { ProductReviewsLink } from "@laioutr-core/canonical-types/ecommerce";
 import { currentProductIdsToken } from "../../const/passthroughTokens.js";
 import { defineShopwareLink } from "../../middleware/defineShopware.js";
-export default defineShopwareLink(ProductReviewsLink, async ({ entityIds, context, pagination, passthrough }) => {
+const REVIEW_SORTINGS = {
+  newest: { field: "createdAt", order: "DESC" },
+  oldest: { field: "createdAt", order: "ASC" },
+  "rating-high": { field: "points", order: "DESC" },
+  "rating-low": { field: "points", order: "ASC" }
+};
+export default defineShopwareLink(ProductReviewsLink, async ({ entityIds, context, pagination, sorting, filter, passthrough }) => {
   const { storefrontClient } = context;
+  const sort = sorting ? REVIEW_SORTINGS[sorting] : void 0;
+  const points = Number(filter?.points);
+  const criteriaFilter = Number.isFinite(points) ? [{ type: "equals", field: "points", value: points }] : void 0;
   const productToReviews = {};
   await Promise.all(
     entityIds.map(async (entityId) => {
@@ -11,6 +20,8 @@ export default defineShopwareLink(ProductReviewsLink, async ({ entityIds, contex
         body: {
           page: pagination.page,
           limit: pagination.limit,
+          ...sort ? { sort: [sort] } : {},
+          ...criteriaFilter ? { filter: criteriaFilter } : {},
           includes: {
             product_review: ["id"]
           }

package/dist/runtime/server/shopware-helper/cartErrors.d.ts

@@ -1,4 +1,27 @@
 import { Schemas } from '../types/storeApiTypes.js';
+export type CartErrorEntry = {
+    key?: string;
+    level?: number;
+    message?: string;
+    messageKey?: string;
+};
+type CartErrors = Schemas['Cart']['errors'] | CartErrorEntry[];
+/**
+ * Split the cart errors that describe a submitted discount code off from the rest.
+ *
+ * `CartAddItemsAction` reports a code it could not redeem as a per-item rejection instead of
+ * failing the whole call, so these are handed back to the caller rather than thrown. Shopware
+ * levels `promotion-not-found` at 20 — the threshold `handleCartMutationErrors` throws on —
+ * while setting `blockOrder(): false` on it.
+ *
+ * Matching is by substring because the keys are not uniformly prefixed: a rejected code is
+ * `promotion-not-found`, an ineligible one carries its reason as a suffix
+ * (`promotion-not-eligible-<reason>`), and the automatic-promotion key leads with `auto-`.
+ */
+export declare const takeDiscountCodeErrors: (errors: CartErrors) => {
+    rejections: CartErrorEntry[];
+    rest: CartErrorEntry[];
+};
 /**
  * Inspect the `errors` of a Shopware cart mutation response.
  *
@@ -8,4 +31,5 @@ import { Schemas } from '../types/storeApiTypes.js';
  * Product* errors is deferred — Shopware's CartError shape carries no reliable
  * variant reference.)
  */
-export declare const handleCartMutationErrors: (errors: Schemas["Cart"]["errors"]) => void;
+export declare const handleCartMutationErrors: (errors: CartErrors) => void;
+export {};

package/dist/runtime/server/shopware-helper/cartErrors.js

@@ -5,6 +5,17 @@ const normalizeCartErrors = (errors) => {
   if (Array.isArray(errors)) return errors;
   return Object.values(errors);
 };
+const autoPromotionNotFoundKey = "auto-promotion-not-found";
+export const takeDiscountCodeErrors = (errors) => {
+  const rejections = [];
+  const rest = [];
+  for (const error of normalizeCartErrors(errors)) {
+    const key = error.messageKey ?? error.key ?? "";
+    if (key.includes("promotion") && key !== autoPromotionNotFoundKey) rejections.push(error);
+    else rest.push(error);
+  }
+  return { rejections, rest };
+};
 export const handleCartMutationErrors = (errors) => {
   for (const error of normalizeCartErrors(errors)) {
     const level = error.level ?? 0;

package/dist/runtime/server/shopware-helper/cartMapper.d.ts

@@ -4,11 +4,33 @@ import { EntityComponentType } from '@laioutr-core/core-types/orchestr';
 import { Schemas } from '../types/storeApiTypes.js';
 /** Map a Shopware cart's aggregate price into the canonical nested `CartCost`. */
 export declare const mapCartCost: (cart: Schemas["Cart"], currency: string) => EntityComponentType<typeof CartCost>;
-/** Map a Shopware product line item into the canonical `CartItem` component values. */
-export declare const mapCartItem: (lineItem: Schemas["LineItem"], currency: string) => {
+type MappedCartItem = {
     base: EntityComponentType<typeof CartItemBase>;
     cost: EntityComponentType<typeof CartItemCost>;
     availability: EntityComponentType<typeof CartItemAvailability>;
     quantityRule: EntityComponentType<typeof CartItemQuantityRule>;
     productData: EntityComponentType<typeof CartItemProductData>;
 };
+/**
+ * Line-item types this app surfaces as canonical `CartItem`s.
+ *
+ * Shopware carries promotions as line items of type `promotion` — both codes the customer
+ * entered and cart-wide discounts the shop applies automatically. Their (negative) price is
+ * already part of `cart.price.positionPrice`, so dropping them leaves a cart whose items add
+ * up to more than its subtotal with nothing to explain the gap.
+ */
+export declare const isSupportedCartLineItem: (lineItem: Schemas["LineItem"]) => boolean;
+/** Map a Shopware product line item into the canonical `CartItem` component values. */
+export declare const mapCartItem: (lineItem: Schemas["LineItem"], currency: string) => MappedCartItem;
+/**
+ * Map a Shopware promotion line item into the canonical `CartItem` component values.
+ *
+ * The amount is negative: Shopware prices a promotion as a discount off the cart, and the
+ * canonical `Money` carries the sign.
+ *
+ * `discount-code` is the closest canonical type, but the code is only there for a promotion
+ * the customer redeemed — an automatic cart discount reaches us with an empty `code` and an
+ * empty `referencedId`, so `code` is left unset rather than blank.
+ */
+export declare const mapDiscountItem: (lineItem: Schemas["LineItem"], currency: string) => MappedCartItem;
+export {};

package/dist/runtime/server/shopware-helper/cartMapper.js

@@ -30,6 +30,7 @@ export const mapCartCost = (cart, currency) => {
     ...taxes.length > 0 ? { taxes } : {}
   };
 };
+export const isSupportedCartLineItem = (lineItem) => lineItem.type === "product" || lineItem.type === "promotion";
 export const mapCartItem = (lineItem, currency) => {
   const money = (value) => Money.fromDecimal(value, currency);
   const price = lineItem.price;
@@ -85,3 +86,29 @@ export const mapCartItem = (lineItem, currency) => {
     productData: void 0
   };
 };
+export const mapDiscountItem = (lineItem, currency) => {
+  const money = (value) => Money.fromDecimal(value, currency);
+  const price = lineItem.price;
+  const total = price?.totalPrice ?? 0;
+  const payload = lineItem.payload ?? {};
+  const code = payload.code || lineItem.referencedId || void 0;
+  return {
+    base: {
+      type: "discount-code",
+      quantity: lineItem.quantity,
+      // Shopware labels the item with the promotion's translated name.
+      title: lineItem.label ?? "",
+      code
+    },
+    cost: {
+      single: money(price?.unitPrice ?? total),
+      subtotal: money(total),
+      total: money(total)
+    },
+    // A promotion in the cart is applied by definition, and its quantity is Shopware's to
+    // decide — the canonical components are required, so they state exactly that.
+    availability: { status: "inStock", quantity: lineItem.quantity },
+    quantityRule: { min: 1, max: 1, increment: 1, canChange: false },
+    productData: void 0
+  };
+};

package/dist/runtime/server/shopware-helper/system/getSystemEntities.js

@@ -34,14 +34,15 @@ export const getSystemEntities = async (client) => {
   };
 };
 const SYSTEM_ENTITIES_TTL = 60 * 60 * 24;
+const entryOptions = { maxAge: SYSTEM_ENTITIES_TTL };
 export const getCachedSystemEntities = async (client) => {
   const accessToken = useRuntimeConfig()["@laioutr/app-shopware"].accessToken;
   const cache = useUserlandCache(`shopware:${accessToken}:system-entities`);
-  const cachedSystemEntities = await cache.getItem("default");
-  if (cachedSystemEntities) {
-    return cachedSystemEntities;
+  const cached = await cache.readOne("default", entryOptions);
+  if (cached && !cached.absent) {
+    return cached.value;
   }
   const systemEntities = await getSystemEntities(client);
-  await cache.setItem("default", systemEntities, { ttl: SYSTEM_ENTITIES_TTL });
+  cache.writeOne("default", systemEntities, entryOptions);
   return systemEntities;
 };

package/dist/runtime/server/shopware-helper/useSeoResolver.js

@@ -2,14 +2,15 @@ import { extractShopwareId, isShopwareId } from "./isShopwareId.js";
 import { isSlugMatchingSeoPath } from "./mappers/slugMapper.js";
 import { useUserlandCache } from "#imports";
 const SEO_ENTRY_TTL = 60 * 60 * 24;
+const entryOptions = { maxAge: SEO_ENTRY_TTL };
 export const useSeoResolver = (storefrontClient, routeNames) => {
   const cache = useUserlandCache("shopware/seo-urls");
   const resolve = async (type, slug) => {
     const languageId = storefrontClient.defaultHeaders["sw-language-id"] ?? "default";
     const cacheKey = `${languageId}:${type}-${slug}`;
-    const cachedSlug = await cache.getItem(cacheKey);
-    if (cachedSlug) {
-      return cachedSlug;
+    const cached = await cache.readOne(cacheKey, entryOptions);
+    if (cached && !cached.absent) {
+      return cached.value;
     }
     const shopwareId = extractShopwareId(slug);
     if (shopwareId) {
@@ -57,7 +58,7 @@ export const useSeoResolver = (storefrontClient, routeNames) => {
       id: bestMatch.foreignKey,
       matchedPath: bestMatch.seoPathInfo
     };
-    await cache.setItem(cacheKey, entry, { ttl: SEO_ENTRY_TTL });
+    cache.writeOne(cacheKey, entry, entryOptions);
     return entry;
   };
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laioutr/app-shopware",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Laioutr integration with Shopware 6",
   "repository": "github:laioutr/app-shopware",
   "license": "MIT",
@@ -22,10 +22,6 @@
   "files": [
     "dist"
   ],
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
   "browserslist": [
     "> 0.5% and not dead"
   ],
@@ -40,12 +36,12 @@
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
     "@laioutr-app/ui": "^2.10.6",
-    "@laioutr-core/canonical-types": "^0.31.0",
-    "@laioutr-core/core-types": "^0.40.3",
-    "@laioutr-core/devtools": "^0.40.3",
-    "@laioutr-core/frontend-core": "^0.40.3",
-    "@laioutr-core/kit": "^0.40.3",
-    "@laioutr-core/orchestr": "^0.40.3",
+    "@laioutr-core/canonical-types": "^0.33.0",
+    "@laioutr-core/core-types": "^0.52.0",
+    "@laioutr-core/devtools": "^0.52.0",
+    "@laioutr-core/frontend-core": "^0.52.0",
+    "@laioutr-core/kit": "^0.52.0",
+    "@laioutr-core/orchestr": "^0.52.0",
     "@laioutr/eslint-config": "^1.9.5",
     "@laioutr/prettier-config": "^1.1.0",
     "@nuxt/devtools": "^2.6.3",
@@ -69,26 +65,30 @@
     "vue-tsc": "2.2.10"
   },
   "peerDependencies": {
-    "@laioutr-core/canonical-types": ">=0.31.0",
-    "@laioutr-core/core-types": ">=0.40.3",
-    "@laioutr-core/frontend-core": ">=0.40.3",
-    "@laioutr-core/kit": ">=0.40.3",
-    "@laioutr-core/orchestr": ">=0.40.3"
+    "@laioutr-core/canonical-types": ">=0.33.0",
+    "@laioutr-core/core-types": ">=0.52.0",
+    "@laioutr-core/frontend-core": ">=0.52.0",
+    "@laioutr-core/kit": ">=0.52.0",
+    "@laioutr-core/orchestr": ">=0.52.0"
   },
   "engines": {
     "node": ">=22.12.0",
     "pnpm": ">=10.15.0"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
+    "changeset": "changeset",
     "dev": "npm run dev:prepare && nuxi dev playground",
     "dev:build": "nuxi build playground",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
     "lint": "eslint .",
-    "changeset": "changeset",
-    "version": "changeset version",
     "release": "pnpm run prepack && changeset publish",
     "test": "vitest run",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
-    "test:watch": "vitest watch"
+    "test:watch": "vitest watch",
+    "version": "changeset version"
   }
 }