includio-cms 0.27.0 → 0.33.0

package/dist/shop/server/invoices.js

@@ -0,0 +1,237 @@
+import { eq } from 'drizzle-orm';
+import { shopInvoicesTable, shopOrderItemsTable, shopOrdersTable } from '../../db-postgres/schema/shop/index.js';
+import { getShopDb, requireShopConfig } from './db.js';
+const FULLY_PAID_STATES = new Set(['paid', 'preparing', 'sent', 'done']);
+export class InvoiceError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'InvoiceError';
+    }
+}
+/** Does the order qualify for an automatic invoice under `policy`? Pure. */
+export function shouldIssueInvoice(order, policy) {
+    if (policy === 'always')
+        return true;
+    return Boolean(order.customerNip) || order.invoiceRequested;
+}
+/** Fully paid = a paid-or-later status with no outstanding balance. Pure. */
+export function isOrderFullyPaid(order) {
+    return FULLY_PAID_STATES.has(order.status) && !order.balanceOwed;
+}
+/**
+ * Decide what to do with an order's invoice given any existing record. Pure —
+ * encodes the trigger + idempotency rules so they can be tested without a DB.
+ */
+export function decideInvoiceAction(order, existing, policy, opts = {}) {
+    if (!isOrderFullyPaid(order))
+        return 'skip';
+    const force = opts.force ?? false;
+    if (existing) {
+        switch (existing.status) {
+            case 'issued':
+            case 'sent':
+                return force ? 'resend' : 'skip';
+            case 'failed':
+                return 'create';
+            case 'pending':
+                return force ? 'create' : 'skip';
+        }
+    }
+    if (force || shouldIssueInvoice(order, policy))
+        return 'create';
+    return 'skip';
+}
+// Order-item `nameSnapshot` is `{ product, variant }` (see createOrderFromCart).
+// The invoice line shows both so the customer sees the exact session they paid
+// for (e.g. "Odporność psychiczna — Poznań • 20 września 2026").
+function lineName(name) {
+    const product = name.product ?? '';
+    const variant = name.variant ?? '';
+    if (product && variant)
+        return `${product} — ${variant}`;
+    return product || variant || Object.values(name)[0] || '';
+}
+/** Map order + items onto the provider-agnostic {@link InvoicePayload}. Pure. */
+export function buildInvoicePayload(order, items, paidAt) {
+    return {
+        orderNumber: order.number,
+        currency: order.currency,
+        paidAt,
+        buyer: {
+            name: order.customerName || order.customerEmail,
+            email: order.customerEmail,
+            nip: order.customerNip,
+            companyName: order.customerCompanyName,
+            address: order.billingAddress ?? order.shippingAddress ?? null
+        },
+        items: items.map((item) => ({
+            name: lineName(item.nameSnapshot),
+            quantity: item.qty,
+            unitPriceGross: item.priceGrossSnapshot,
+            vatRate: item.vatRate
+        }))
+    };
+}
+export async function getInvoiceByOrderId(orderId) {
+    const db = getShopDb();
+    const [row] = await db
+        .select()
+        .from(shopInvoicesTable)
+        .where(eq(shopInvoicesTable.orderId, orderId));
+    return row ?? null;
+}
+function toOrderData(order) {
+    return {
+        number: order.number,
+        currency: order.currency,
+        customerEmail: order.customerEmail,
+        customerName: order.customerName,
+        customerNip: order.customerNip,
+        customerCompanyName: order.customerCompanyName,
+        shippingAddress: order.shippingAddress ?? null,
+        billingAddress: order.billingAddress ?? null,
+        language: order.language
+    };
+}
+function toItemData(items) {
+    return items.map((i) => ({
+        nameSnapshot: i.nameSnapshot,
+        qty: i.qty,
+        priceGrossSnapshot: i.priceGrossSnapshot,
+        vatRate: i.vatRate
+    }));
+}
+async function runCreate(order, existing, adapter) {
+    const db = getShopDb();
+    const now = new Date();
+    let invoiceId;
+    if (existing) {
+        const [row] = await db
+            .update(shopInvoicesTable)
+            .set({
+            status: 'pending',
+            provider: adapter.id,
+            attempts: existing.attempts + 1,
+            lastError: null,
+            updatedAt: now
+        })
+            .where(eq(shopInvoicesTable.id, existing.id))
+            .returning();
+        invoiceId = row.id;
+    }
+    else {
+        const [row] = await db
+            .insert(shopInvoicesTable)
+            .values({
+            orderId: order.id,
+            provider: adapter.id,
+            status: 'pending',
+            attempts: 1
+        })
+            .returning();
+        invoiceId = row.id;
+    }
+    const items = await db
+        .select()
+        .from(shopOrderItemsTable)
+        .where(eq(shopOrderItemsTable.orderId, order.id));
+    const paidAt = order.partialPayment?.paidAt ?? now.toISOString();
+    const payload = buildInvoicePayload(toOrderData(order), toItemData(items), paidAt);
+    try {
+        const result = await adapter.createInvoice(payload, { language: order.language });
+        let status = 'issued';
+        if (adapter.send) {
+            await adapter.send(result.externalId, { language: order.language });
+            status = 'sent';
+        }
+        const [updated] = await db
+            .update(shopInvoicesTable)
+            .set({
+            status,
+            externalId: result.externalId,
+            number: result.number ?? null,
+            pdfUrl: result.pdfUrl ?? null,
+            raw: result.raw ?? null,
+            lastError: null,
+            updatedAt: new Date()
+        })
+            .where(eq(shopInvoicesTable.id, invoiceId))
+            .returning();
+        return updated;
+    }
+    catch (err) {
+        await db
+            .update(shopInvoicesTable)
+            .set({
+            status: 'failed',
+            lastError: err instanceof Error ? err.message : String(err),
+            updatedAt: new Date()
+        })
+            .where(eq(shopInvoicesTable.id, invoiceId));
+        throw err;
+    }
+}
+async function runResend(order, existing, adapter) {
+    if (!existing.externalId)
+        throw new InvoiceError('not_issued', 'No issued invoice to resend');
+    if (!adapter.send)
+        throw new InvoiceError('send_unsupported', 'Adapter cannot e-mail invoices');
+    const db = getShopDb();
+    await adapter.send(existing.externalId, { language: order.language });
+    const [updated] = await db
+        .update(shopInvoicesTable)
+        .set({ status: 'sent', updatedAt: new Date() })
+        .where(eq(shopInvoicesTable.id, existing.id))
+        .returning();
+    return updated;
+}
+/**
+ * Issue an invoice for an order if it qualifies. Fire-and-forget, fail-open —
+ * never throws, so a failing invoicing provider can't block the payment webhook.
+ * Called from `updateOrderStatus` (on `paid`) and `markBalancePaid`.
+ */
+export async function maybeIssueInvoiceForOrder(orderId) {
+    try {
+        const adapter = requireShopConfig().invoicing;
+        if (!adapter)
+            return;
+        const db = getShopDb();
+        const [order] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.id, orderId));
+        if (!order)
+            return;
+        const existing = await getInvoiceByOrderId(orderId);
+        const policy = adapter.issueWhen ?? 'b2bAndOnRequest';
+        const action = decideInvoiceAction(order, existing, policy);
+        if (action === 'create')
+            await runCreate(order, existing, adapter);
+        else if (action === 'resend' && existing)
+            await runResend(order, existing, adapter);
+    }
+    catch (err) {
+        console.error(`[shop] invoice issuance failed for order ${orderId}:`, err);
+    }
+}
+/**
+ * Issue (or retry/resend) an invoice on demand from the admin. Throws on error
+ * so the caller can surface it. `force` bypasses the trigger policy and allows
+ * re-sending an already-issued invoice.
+ */
+export async function issueInvoiceForOrder(orderId, opts = {}) {
+    const adapter = requireShopConfig().invoicing;
+    if (!adapter)
+        throw new InvoiceError('no_adapter', 'No invoicing adapter configured');
+    const db = getShopDb();
+    const [order] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.id, orderId));
+    if (!order)
+        throw new InvoiceError('order_not_found', 'Order not found');
+    const existing = await getInvoiceByOrderId(orderId);
+    const policy = adapter.issueWhen ?? 'b2bAndOnRequest';
+    const action = decideInvoiceAction(order, existing, policy, { force: opts.force ?? false });
+    if (action === 'create')
+        return runCreate(order, existing, adapter);
+    if (action === 'resend' && existing)
+        return runResend(order, existing, adapter);
+    return existing;
+}

package/dist/shop/server/orders.d.ts

@@ -13,6 +13,43 @@ export declare class MixedPaymentPolicyError extends Error {
     readonly code = "MIXED_PAYMENT_POLICY";
     constructor(message?: string);
 }
+/**
+ * @public
+ * Order statuses an admin is allowed to soft-delete (hide from the admin list).
+ * Restricted to states that never carry a settled payment or an issued invoice,
+ * so hiding one can't bury accounting/audit data. Paid-or-later and `refunded`
+ * orders are never deletable. The invoice guard in `softDeleteOrder` is the
+ * second line of defence.
+ */
+export declare const DELETABLE_ORDER_STATUSES: Set<OrderStatus>;
+/** @public Pure status-level deletability check (no DB / invoice lookup). */
+export declare function isOrderDeletable(status: OrderStatus): boolean;
+export type OrderDeletionDecision = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'status' | 'invoice';
+};
+/**
+ * @public
+ * Pure decision: may this order be soft-deleted? Encodes both guards (status +
+ * existing invoice) so they're testable without a DB. `invoice` is the order's
+ * current invoice record (or null). An `issued`/`sent` invoice hard-blocks the
+ * delete; `pending`/`failed` invoices don't (no legal document was produced).
+ */
+export declare function decideOrderDeletion(status: OrderStatus, invoice: {
+    status: 'pending' | 'issued' | 'sent' | 'failed';
+} | null): OrderDeletionDecision;
+/**
+ * @public
+ * Thrown by `softDeleteOrder` when the order can't be hidden: either its status
+ * isn't in {@link DELETABLE_ORDER_STATUSES} or it already has an issued invoice.
+ */
+export declare class OrderNotDeletableError extends Error {
+    readonly reason: 'status' | 'invoice';
+    readonly code = "ORDER_NOT_DELETABLE";
+    constructor(reason: 'status' | 'invoice');
+}
 export type OrderRow = typeof shopOrdersTable.$inferSelect;
 export type OrderItemRow = typeof shopOrderItemsTable.$inferSelect;
 export type OrderStatusHistoryRow = typeof shopOrderStatusHistoryTable.$inferSelect;
@@ -25,7 +62,11 @@ export interface CreateOrderInput {
     customerEmail: string;
     customerName?: string;
     customerPhone?: string;
+    customerNip?: string;
+    customerCompanyName?: string;
     shippingAddress?: Record<string, string>;
+    billingAddress?: Record<string, string>;
+    invoiceRequested?: boolean;
     shippingMethodId: string;
     carrierRef?: string;
     paymentMethod: string;
@@ -83,9 +124,31 @@ export declare function getOrderItems(orderId: string): Promise<OrderItemRow[]>;
 export declare function getOrderStatusHistory(orderId: string): Promise<OrderStatusHistoryRow[]>;
 export interface ListOrdersOptions {
     status?: OrderStatus;
-    email?: string;
+    search?: string;
     limit?: number;
     offset?: number;
+    /**
+     * Soft-delete visibility. `'exclude'` (default) hides soft-deleted orders —
+     * the normal admin/customer list. `'only'` returns just the trash; `'include'`
+     * returns everything regardless of `deletedAt`.
+     */
+    deleted?: 'exclude' | 'only' | 'include';
 }
 export declare function listOrders(opts?: ListOrdersOptions): Promise<OrderRow[]>;
 export declare function countOrders(opts?: Omit<ListOrdersOptions, 'limit' | 'offset'>): Promise<number>;
+/**
+ * @public
+ * Soft-delete an order: hide it from the admin/customer list without removing
+ * the row (accounting/audit safety). Idempotent — a no-op on an already-deleted
+ * order. Guards on {@link decideOrderDeletion}: throws {@link OrderNotDeletableError}
+ * when the status isn't deletable or an issued/sent invoice exists. Releases any
+ * active stock reservation immediately so a hidden, abandoned order never locks
+ * stock waiting for the TTL.
+ */
+export declare function softDeleteOrder(orderId: string, deletedBy: string): Promise<OrderRow>;
+/**
+ * @public
+ * Restore a soft-deleted order back to the visible list. Idempotent — a no-op
+ * on an order that isn't deleted.
+ */
+export declare function restoreOrder(orderId: string): Promise<OrderRow>;

package/dist/shop/server/orders.js

@@ -1,4 +1,4 @@
-import { and, asc, desc, eq, inArray, isNull, lt, sql } from 'drizzle-orm';
+import { and, asc, desc, eq, ilike, inArray, isNotNull, isNull, lt, or, sql } from 'drizzle-orm';
 import { shopOrderItemsTable, shopOrderStatusHistoryTable, shopOrdersTable, shopProductVariantsTable, shopProductsTable, shopShippingMethodsTable, shopStockReservationsTable } from '../../db-postgres/schema/shop/index.js';
 import { getCMS } from '../../core/cms.js';
 import { getShopDb, requireShopConfig } from './db.js';
@@ -9,6 +9,7 @@ import { sendLowStockEmail, sendOrderStatusEmail } from './email.js';
 import { isPaymentMethodAllowed } from './payment-compat.js';
 import { isVariantExpired, VariantExpiredError } from '../expiry.js';
 import { resolvePaymentAmount } from './payment-policy.js';
+import { getInvoiceByOrderId, maybeIssueInvoiceForOrder } from './invoices.js';
 import { CouponError, recordCouponRedemption, releaseCouponSlot, reserveCouponSlot, validateCoupon } from './coupons.js';
 /**
  * @public
@@ -26,6 +27,55 @@ export class MixedPaymentPolicyError extends Error {
     }
 }
 const STOCK_RESERVATION_TTL_MINUTES = 30;
+/**
+ * @public
+ * Order statuses an admin is allowed to soft-delete (hide from the admin list).
+ * Restricted to states that never carry a settled payment or an issued invoice,
+ * so hiding one can't bury accounting/audit data. Paid-or-later and `refunded`
+ * orders are never deletable. The invoice guard in `softDeleteOrder` is the
+ * second line of defence.
+ */
+export const DELETABLE_ORDER_STATUSES = new Set([
+    'new',
+    'awaitingPayment',
+    'cancelled',
+    'paymentRejected'
+]);
+/** @public Pure status-level deletability check (no DB / invoice lookup). */
+export function isOrderDeletable(status) {
+    return DELETABLE_ORDER_STATUSES.has(status);
+}
+/**
+ * @public
+ * Pure decision: may this order be soft-deleted? Encodes both guards (status +
+ * existing invoice) so they're testable without a DB. `invoice` is the order's
+ * current invoice record (or null). An `issued`/`sent` invoice hard-blocks the
+ * delete; `pending`/`failed` invoices don't (no legal document was produced).
+ */
+export function decideOrderDeletion(status, invoice) {
+    if (!isOrderDeletable(status))
+        return { ok: false, reason: 'status' };
+    if (invoice && (invoice.status === 'issued' || invoice.status === 'sent')) {
+        return { ok: false, reason: 'invoice' };
+    }
+    return { ok: true };
+}
+/**
+ * @public
+ * Thrown by `softDeleteOrder` when the order can't be hidden: either its status
+ * isn't in {@link DELETABLE_ORDER_STATUSES} or it already has an issued invoice.
+ */
+export class OrderNotDeletableError extends Error {
+    reason;
+    code = 'ORDER_NOT_DELETABLE';
+    constructor(reason) {
+        super(reason === 'invoice'
+            ? 'Order has an issued invoice and cannot be deleted.'
+            : 'Order status does not allow deletion.');
+        this.reason = reason;
+        this.name = 'OrderNotDeletableError';
+    }
+}
 async function purgeExpiredReservations() {
     const db = getShopDb();
     await db
@@ -237,7 +287,11 @@ export async function createOrderFromCart(input) {
             customerEmail: input.customerEmail,
             customerName: input.customerName ?? null,
             customerPhone: input.customerPhone ?? null,
+            customerNip: input.customerNip ?? null,
+            customerCompanyName: input.customerCompanyName ?? null,
             shippingAddress: input.shippingAddress ?? null,
+            billingAddress: input.billingAddress ?? null,
+            invoiceRequested: input.invoiceRequested ?? false,
             totalNet,
             totalGross,
             vatAmount: totalVat,
@@ -356,9 +410,18 @@ export async function updateOrderStatus(orderId, status, opts = {}) {
         })
             .where(eq(shopOrdersTable.id, orderId));
     }
+    // Auto-restore: a soft-deleted order may only sit in a deletable status. If
+    // it transitions out of that set (e.g. a late payment webhook flips a hidden
+    // `awaitingPayment` order to `paid`), un-hide it so settled orders are never
+    // buried in the trash.
+    const autoRestore = order.deletedAt != null && !isOrderDeletable(status);
     await db
         .update(shopOrdersTable)
-        .set({ status, updatedAt: new Date() })
+        .set({
+        status,
+        updatedAt: new Date(),
+        ...(autoRestore ? { deletedAt: null, deletedBy: null } : {})
+    })
         .where(eq(shopOrdersTable.id, orderId));
     await db.insert(shopOrderStatusHistoryTable).values({
         orderId,
@@ -430,6 +493,18 @@ export async function updateOrderStatus(orderId, status, opts = {}) {
     }
     const [updated] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.id, orderId));
     void sendOrderStatusEmail(orderId, status);
+    // Auto-issue an invoice once the order is paid. Fail-open / fire-and-forget —
+    // the guard inside skips deposit orders that still owe a balance.
+    if (status === 'paid')
+        void maybeIssueInvoiceForOrder(orderId);
+    // User-land `onOrderPaid` hook — fires on transition INTO `paid` only
+    // (no-op when oldStatus === 'paid'). Errors swallowed so a buggy callback
+    // never blocks the webhook / status write.
+    if (order.status !== 'paid' && status === 'paid' && shop.onOrderPaid && updated) {
+        Promise.resolve(shop.onOrderPaid(updated)).catch((e) => {
+            console.error('[onOrderPaid] callback failed', e);
+        });
+    }
     return updated;
 }
 /**
@@ -461,6 +536,8 @@ export async function markBalancePaid(orderId) {
     })
         .where(eq(shopOrdersTable.id, orderId));
     const [updated] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.id, orderId));
+    // Balance cleared → the order is now fully paid; issue its invoice.
+    void maybeIssueInvoiceForOrder(orderId);
     return updated ?? null;
 }
 export async function setPaymentProviderRef(orderId, ref) {
@@ -522,7 +599,12 @@ export async function getOrderById(id) {
 }
 export async function getOrderByNumber(number) {
     const db = getShopDb();
-    const [row] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.number, number));
+    // Customer-facing lookup — a soft-deleted order must not resolve on the
+    // storefront. (Admin uses getOrderById, which intentionally ignores deletedAt.)
+    const [row] = await db
+        .select()
+        .from(shopOrdersTable)
+        .where(and(eq(shopOrdersTable.number, number), isNull(shopOrdersTable.deletedAt)));
     return row ?? null;
 }
 export async function getOrderItems(orderId) {
@@ -537,16 +619,28 @@ export async function getOrderStatusHistory(orderId) {
         .where(eq(shopOrderStatusHistoryTable.orderId, orderId))
         .orderBy(asc(shopOrderStatusHistoryTable.changedAt));
 }
-export async function listOrders(opts = {}) {
-    const db = getShopDb();
+function escapeLike(value) {
+    return value.replace(/[\\%_]/g, (m) => `\\${m}`);
+}
+function buildOrderListConditions(opts) {
     const conditions = [];
+    const deleted = opts.deleted ?? 'exclude';
+    if (deleted === 'exclude')
+        conditions.push(isNull(shopOrdersTable.deletedAt));
+    else if (deleted === 'only')
+        conditions.push(isNotNull(shopOrdersTable.deletedAt));
     if (opts.status)
         conditions.push(eq(shopOrdersTable.status, opts.status));
-    if (opts.email)
-        conditions.push(eq(shopOrdersTable.customerEmail, opts.email));
-    // Exclude soft-deleted if such a column existed; none now
-    // Avoid unused import warning
-    void isNull;
+    const search = opts.search?.trim();
+    if (search) {
+        const pattern = `%${escapeLike(search)}%`;
+        conditions.push(or(ilike(shopOrdersTable.number, pattern), ilike(shopOrdersTable.customerEmail, pattern), ilike(shopOrdersTable.customerName, pattern)));
+    }
+    return conditions;
+}
+export async function listOrders(opts = {}) {
+    const db = getShopDb();
+    const conditions = buildOrderListConditions(opts);
     const where = conditions.length > 0 ? and(...conditions) : undefined;
     return db
         .select()
@@ -558,11 +652,7 @@ export async function listOrders(opts = {}) {
 }
 export async function countOrders(opts = {}) {
     const db = getShopDb();
-    const conditions = [];
-    if (opts.status)
-        conditions.push(eq(shopOrdersTable.status, opts.status));
-    if (opts.email)
-        conditions.push(eq(shopOrdersTable.customerEmail, opts.email));
+    const conditions = buildOrderListConditions(opts);
     const where = conditions.length > 0 ? and(...conditions) : undefined;
     const [row] = await db
         .select({ count: sql `count(*)::int` })
@@ -570,3 +660,53 @@ export async function countOrders(opts = {}) {
         .where(where);
     return row?.count ?? 0;
 }
+/**
+ * @public
+ * Soft-delete an order: hide it from the admin/customer list without removing
+ * the row (accounting/audit safety). Idempotent — a no-op on an already-deleted
+ * order. Guards on {@link decideOrderDeletion}: throws {@link OrderNotDeletableError}
+ * when the status isn't deletable or an issued/sent invoice exists. Releases any
+ * active stock reservation immediately so a hidden, abandoned order never locks
+ * stock waiting for the TTL.
+ */
+export async function softDeleteOrder(orderId, deletedBy) {
+    const db = getShopDb();
+    const [order] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.id, orderId));
+    if (!order)
+        throw new Error('Order not found');
+    if (order.deletedAt)
+        return order;
+    const invoice = await getInvoiceByOrderId(orderId);
+    const decision = decideOrderDeletion(order.status, invoice);
+    if (!decision.ok)
+        throw new OrderNotDeletableError(decision.reason);
+    // Free held stock right away (no rows when the stock feature is off).
+    await db
+        .delete(shopStockReservationsTable)
+        .where(eq(shopStockReservationsTable.orderId, orderId));
+    await db
+        .update(shopOrdersTable)
+        .set({ deletedAt: new Date(), deletedBy, updatedAt: new Date() })
+        .where(eq(shopOrdersTable.id, orderId));
+    const [updated] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.id, orderId));
+    return updated;
+}
+/**
+ * @public
+ * Restore a soft-deleted order back to the visible list. Idempotent — a no-op
+ * on an order that isn't deleted.
+ */
+export async function restoreOrder(orderId) {
+    const db = getShopDb();
+    const [order] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.id, orderId));
+    if (!order)
+        throw new Error('Order not found');
+    if (!order.deletedAt)
+        return order;
+    await db
+        .update(shopOrdersTable)
+        .set({ deletedAt: null, deletedBy: null, updatedAt: new Date() })
+        .where(eq(shopOrdersTable.id, orderId));
+    const [updated] = await db.select().from(shopOrdersTable).where(eq(shopOrdersTable.id, orderId));
+    return updated;
+}

package/dist/shop/templates/_partials/footer.en.html

@@ -0,0 +1,4 @@
+  </div>
+  <p style="text-align:center;color:#8888A0;font-size:12px;margin-top:16px;">AriaCMS · {{order.customerEmail}}</p>
+</div>
+</body></html>

package/dist/shop/templates/_partials/footer.pl.html

@@ -0,0 +1,4 @@
+  </div>
+  <p style="text-align:center;color:#8888A0;font-size:12px;margin-top:16px;">AriaCMS · {{order.customerEmail}}</p>
+</div>
+</body></html>

package/dist/shop/templates/_partials/header.en.html

@@ -0,0 +1,4 @@
+<!doctype html>
+<html lang="en"><body style="margin:0;padding:0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Helvetica,Arial,sans-serif;background:#f5f5f8;color:#1a1a2e;">
+<div style="max-width:560px;margin:0 auto;padding:24px;">
+  <div style="background:#fff;border-radius:12px;padding:28px;">

package/dist/shop/templates/_partials/header.pl.html

@@ -0,0 +1,4 @@
+<!doctype html>
+<html lang="pl"><body style="margin:0;padding:0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Helvetica,Arial,sans-serif;background:#f5f5f8;color:#1a1a2e;">
+<div style="max-width:560px;margin:0 auto;padding:24px;">
+  <div style="background:#fff;border-radius:12px;padding:28px;">

package/dist/shop/templates/_partials/items.en.html

@@ -0,0 +1,14 @@
+<table style="width:100%;border-collapse:collapse;font-size:14px;">
+  <thead><tr style="background:#f4f2fa;"><th align="left" style="padding:8px;">Item</th><th style="padding:8px;">Qty</th><th align="right" style="padding:8px;">Total</th></tr></thead>
+  <tbody>
+    {{#each items}}
+      <tr><td style="padding:6px 8px;border-bottom:1px solid #eee;">{{name}}</td><td style="padding:6px 8px;border-bottom:1px solid #eee;text-align:center;">{{qty}}</td><td style="padding:6px 8px;border-bottom:1px solid #eee;text-align:right;">{{lineGross}}</td></tr>
+    {{/each}}
+  </tbody>
+</table>
+<div style="margin-top:16px;text-align:right;font-size:14px;line-height:1.7;">
+  <div>Shipping: <strong>{{order.shippingGross}}</strong></div>
+  {{#if order.hasDiscount}}<div>Discount ({{order.couponCode}}): <strong style="color:#5B4A9E;">−{{order.discountAmount}}</strong></div>{{/if}}
+  <div style="font-size:16px;">Total (gross): <strong style="color:#5B4A9E;">{{order.totalGross}}</strong></div>
+  <div style="color:#8888A0;font-size:12px;">net {{order.totalNet}} · VAT {{order.vatAmount}}</div>
+</div>

package/dist/shop/templates/_partials/items.pl.html

@@ -0,0 +1,14 @@
+<table style="width:100%;border-collapse:collapse;font-size:14px;">
+  <thead><tr style="background:#f4f2fa;"><th align="left" style="padding:8px;">Pozycja</th><th style="padding:8px;">Ilość</th><th align="right" style="padding:8px;">Suma</th></tr></thead>
+  <tbody>
+    {{#each items}}
+      <tr><td style="padding:6px 8px;border-bottom:1px solid #eee;">{{name}}</td><td style="padding:6px 8px;border-bottom:1px solid #eee;text-align:center;">{{qty}}</td><td style="padding:6px 8px;border-bottom:1px solid #eee;text-align:right;">{{lineGross}}</td></tr>
+    {{/each}}
+  </tbody>
+</table>
+<div style="margin-top:16px;text-align:right;font-size:14px;line-height:1.7;">
+  <div>Wysyłka: <strong>{{order.shippingGross}}</strong></div>
+  {{#if order.hasDiscount}}<div>Rabat ({{order.couponCode}}): <strong style="color:#5B4A9E;">−{{order.discountAmount}}</strong></div>{{/if}}
+  <div style="font-size:16px;">Razem (brutto): <strong style="color:#5B4A9E;">{{order.totalGross}}</strong></div>
+  <div style="color:#8888A0;font-size:12px;">netto {{order.totalNet}} · VAT {{order.vatAmount}}</div>
+</div>

package/dist/shop/templates/_partials/tracking.en.html

@@ -0,0 +1,7 @@
+{{#if tracking}}
+<div style="margin-top:20px;padding:16px;background:#F4F2FA;border-radius:10px;font-size:14px;">
+  <div style="color:#555566;margin-bottom:4px;">{{tracking.label}}</div>
+  <div style="font-family:ui-monospace,monospace;font-weight:700;word-break:break-all;">{{tracking.number}}</div>
+  {{#if tracking.url}}<a href="{{tracking.url}}" style="display:inline-block;margin-top:8px;color:#5B4A9E;font-weight:600;text-decoration:none;">{{tracking.linkLabel}}</a>{{/if}}
+</div>
+{{/if}}

package/dist/shop/templates/_partials/tracking.pl.html

@@ -0,0 +1,7 @@
+{{#if tracking}}
+<div style="margin-top:20px;padding:16px;background:#F4F2FA;border-radius:10px;font-size:14px;">
+  <div style="color:#555566;margin-bottom:4px;">{{tracking.label}}</div>
+  <div style="font-family:ui-monospace,monospace;font-weight:700;word-break:break-all;">{{tracking.number}}</div>
+  {{#if tracking.url}}<a href="{{tracking.url}}" style="display:inline-block;margin-top:8px;color:#5B4A9E;font-weight:600;text-decoration:none;">{{tracking.linkLabel}}</a>{{/if}}
+</div>
+{{/if}}

package/dist/shop/templates/awaiting-payment.en.html

@@ -0,0 +1,6 @@
+{{> header}}
+<h1 style="font-size:20px;font-weight:800;margin:0 0 8px;">Awaiting payment</h1>
+<p style="margin:0 0 20px;color:#555566;line-height:1.5;">Your order {{order.number}} has been placed. Waiting for payment per the chosen method.</p>
+{{> items}}
+{{#if viewUrl}}<div style="margin-top:24px;text-align:center;"><a href="{{viewUrl}}" style="display:inline-block;background:#5B4A9E;color:#fff;text-decoration:none;padding:10px 18px;border-radius:8px;font-weight:600;">{{viewLinkLabel}}</a></div>{{/if}}
+{{> footer}}

package/dist/shop/templates/awaiting-payment.pl.html

@@ -0,0 +1,6 @@
+{{> header}}
+<h1 style="font-size:20px;font-weight:800;margin:0 0 8px;">Czekamy na płatność</h1>
+<p style="margin:0 0 20px;color:#555566;line-height:1.5;">Otrzymaliśmy zamówienie {{order.number}}. Czekamy na płatność zgodnie z wybraną metodą.</p>
+{{> items}}
+{{#if viewUrl}}<div style="margin-top:24px;text-align:center;"><a href="{{viewUrl}}" style="display:inline-block;background:#5B4A9E;color:#fff;text-decoration:none;padding:10px 18px;border-radius:8px;font-weight:600;">{{viewLinkLabel}}</a></div>{{/if}}
+{{> footer}}

package/dist/shop/templates/cancelled.en.html

@@ -0,0 +1,6 @@
+{{> header}}
+<h1 style="font-size:20px;font-weight:800;margin:0 0 8px;">Order cancelled</h1>
+<p style="margin:0 0 20px;color:#555566;line-height:1.5;">Order {{order.number}} has been cancelled.</p>
+{{> items}}
+{{#if viewUrl}}<div style="margin-top:24px;text-align:center;"><a href="{{viewUrl}}" style="display:inline-block;background:#5B4A9E;color:#fff;text-decoration:none;padding:10px 18px;border-radius:8px;font-weight:600;">{{viewLinkLabel}}</a></div>{{/if}}
+{{> footer}}