@mohasinac/appkit 4.43.0 → 4.45.0

package/dist/features/stores/server.js

@@ -3,11 +3,11 @@
  *
  * Server-only entry point — repositories and API route handlers.
  */
-export * from "./actions";
-export { StoreRepository, storeRepository, } from "./repository/store.repository";
+export * from "./actions/index.js";
+export { StoreRepository, storeRepository, } from "./repository/store.repository.js";
 // SB-UNI-A 2026-05-13 — storeAddressRepository deleted. Use addressesRepository
 // (top-level addresses collection with ownerType:"store").
-export { GET as storeSlugGET } from "./api/[storeSlug]/route";
-export { GET as storeProductsGET } from "./api/[storeSlug]/products/route";
-export { GET as storeAuctionsGET } from "./api/[storeSlug]/auctions/route";
-export { GET as storeReviewsGET } from "./api/[storeSlug]/reviews/route";
+export { GET as storeSlugGET } from "./api/[storeSlug]/route.js";
+export { GET as storeProductsGET } from "./api/[storeSlug]/products/route.js";
+export { GET as storeAuctionsGET } from "./api/[storeSlug]/auctions/route.js";
+export { GET as storeReviewsGET } from "./api/[storeSlug]/reviews/route.js";

package/dist/features/stores/types/index.d.ts

@@ -14,6 +14,16 @@ export interface StoreListItem {
     itemsSold?: number;
     totalReviews?: number;
     averageRating?: number;
+    /**
+     * Buyer protections this seller supports — C5e, tier 2 of three.
+     *
+     * 🛑 On the LIST item, not just the detail, because the safety badge and the
+     * risk notice both belong on a store card. And NOT optional here even though
+     * the document field is: the projection resolves absence to `false` so the
+     * client never has to decide what `undefined` means (see `toStoreListItem`).
+     */
+    supportsShippingProtection: boolean;
+    supportsSaleProtection: boolean;
     createdAt?: string;
 }
 export interface StoreDetail extends StoreListItem {

package/dist/features/support/repository/support.repository.js

@@ -1,14 +1,14 @@
-import { firebaseFieldOps } from "../../../providers/db-firebase";
-import { BaseRepository, prepareForFirestore, parseSieveDateValue, } from "../../../providers/db-firebase";
-import { normalizeError } from "../../../errors/normalize";
-import { DatabaseError } from "../../../errors";
-import { SUPPORT_TICKET_FIELDS } from "../../../constants/field-names";
-import { buildSearchTxt } from "../../../utils/search-txt";
-import { planSearchTxt, emptySearchResult } from "../../../utils/search-txt-query";
-import { sieveAnd, sieveFilter, SIEVE_OP } from "../../../utils/sieve-builder";
-import { decryptPiiFields } from "../../../security/pii-encrypt";
-import { SUPPORT_TICKET_COLLECTION, SUPPORT_TICKET_PII_FIELDS, SUPPORT_TICKET_TRACKED_FIELDS, TicketStatusValues, ACTIVE_TICKET_STATUSES, } from "../schemas/firestore";
-import { withHistory } from "../../../_internal/shared/history/index";
+import { firebaseFieldOps } from "../../../providers/db-firebase/index.js";
+import { BaseRepository, prepareForFirestore, parseSieveDateValue, } from "../../../providers/db-firebase/index.js";
+import { normalizeError } from "../../../errors/normalize.js";
+import { DatabaseError } from "../../../errors/index.js";
+import { SUPPORT_TICKET_FIELDS } from "../../../constants/field-names.js";
+import { buildSearchTxt } from "../../../utils/search-txt.js";
+import { planSearchTxt, emptySearchResult } from "../../../utils/search-txt-query.js";
+import { sieveAnd, sieveFilter, SIEVE_OP } from "../../../utils/sieve-builder.js";
+import { decryptPiiFields } from "../../../security/pii-encrypt.js";
+import { SUPPORT_TICKET_COLLECTION, SUPPORT_TICKET_PII_FIELDS, SUPPORT_TICKET_TRACKED_FIELDS, TicketStatusValues, ACTIVE_TICKET_STATUSES, } from "../schemas/firestore.js";
+import { withHistory } from "../../../_internal/shared/history/index.js";
 export class SupportRepository extends BaseRepository {
     constructor() {
         super(SUPPORT_TICKET_COLLECTION);

package/dist/features/support/schemas/index.d.ts

@@ -157,7 +157,7 @@ export declare const supportTicketFirestoreSchema: z.ZodObject<{
     updatedAt: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
-    category: "general" | "account" | "order_issue" | "billing_payment" | "listing_dispute" | "scam_report" | "refund_request" | "auction_dispute" | "store_change_request" | "order_modification_request" | "unban_request";
+    category: "general" | "order_issue" | "billing_payment" | "account" | "listing_dispute" | "scam_report" | "refund_request" | "auction_dispute" | "store_change_request" | "order_modification_request" | "unban_request";
     priority: "normal" | "high" | "low" | "urgent";
     description: string;
     userId: string;
@@ -200,7 +200,7 @@ export declare const supportTicketFirestoreSchema: z.ZodObject<{
     updatedAt: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
-    category: "general" | "account" | "order_issue" | "billing_payment" | "listing_dispute" | "scam_report" | "refund_request" | "auction_dispute" | "store_change_request" | "order_modification_request" | "unban_request";
+    category: "general" | "order_issue" | "billing_payment" | "account" | "listing_dispute" | "scam_report" | "refund_request" | "auction_dispute" | "store_change_request" | "order_modification_request" | "unban_request";
     priority: "normal" | "high" | "low" | "urgent";
     description: string;
     userId: string;

package/dist/features/support/schemas/index.js

@@ -3,8 +3,8 @@
 // Mirrors SupportTicketDocument + TicketMessage + TicketRelatedParties in
 // ./firestore.ts. Registered into SCHEMAS.firestore.supportTickets.
 import { z } from "zod";
-import { auditTimestampsShape, firestoreDateSchema } from "../../../schemas/firestore-helpers";
-export * from "./firestore";
+import { auditTimestampsShape, firestoreDateSchema } from "../../../schemas/firestore-helpers.js";
+export * from "./firestore.js";
 export const ticketCategorySchema = z.enum([
     "order_issue",
     "billing_payment",

package/dist/features/support/schemas/ticket-create-form.js

@@ -27,8 +27,8 @@
  * @tag sideEffects:none
  */
 import { z } from "zod";
-import { annotate } from "../../shell/field-ui-meta";
-import { TicketCategoryValues } from "./firestore";
+import { annotate } from "../../shell/field-ui-meta.js";
+import { TicketCategoryValues } from "./firestore.js";
 /*
  * `Object.values(...)` rather than `z.enum(TicketCategoryValues)`. The object
  * form of `z.enum` is Zod 4 syntax, and appkit compiles against zod 3 while

package/dist/features/tax-codes/repository/tax-codes.repository.d.ts

@@ -0,0 +1,55 @@
+import { BaseRepository, type FirebaseSieveResult, type SieveModel } from "../../../providers/db-firebase";
+import { type TaxCodeCreateInput, type TaxCodeDocument, type TaxCodeUpdateInput } from "../schemas/firestore";
+/**
+ * The `taxCodes` collection.
+ *
+ * Small, read-mostly and read on a hot path — `deriveTaxonomy` resolves a
+ * category's `taxCodeId` on every product create and on any update that names
+ * a taxonomy field. So the two reads below are single-document and
+ * single-field-equality shaped on purpose; neither needs a composite index.
+ */
+export declare class TaxCodesRepository extends BaseRepository<TaxCodeDocument> {
+    constructor();
+    list(model: SieveModel): Promise<FirebaseSieveResult<TaxCodeDocument>>;
+    /**
+     * Every active code, chapter-then-rate ordered, for the picker.
+     *
+     * Unpaginated deliberately — this is ~10 rows and will be a few dozen at
+     * most. If it ever needs paging, the picker needs `searchTxt` first, and
+     * that is a different change.
+     */
+    listActive(): Promise<TaxCodeDocument[]>;
+    /**
+     * Every code including inactive ones, for the admin list.
+     *
+     * 🛑 EXPLICITLY bounded, even though the collection is five rows. Two
+     * reasons: `BaseRepository.findAll()` relies on a cap several layers away
+     * (`base.ts` clamps perPage at 500), and a route that reads "all of a
+     * collection" with no visible bound is the shape that has to be re-audited
+     * every time somebody wonders whether it is safe. 200 is far above any
+     * plausible number of HSN codes and far below anything that costs.
+     */
+    listAllBounded(): Promise<TaxCodeDocument[]>;
+    /**
+     * Resolve a code for derivation.
+     *
+     * 🛑 Returns `null` for an INACTIVE code as well as a missing one, and the
+     * caller must treat both the same way: leave the product's `gstRate` and
+     * `hsnCode` alone rather than writing a zero. Deactivating a code must not
+     * silently re-rate the next listing to 0% — that is indistinguishable from a
+     * deliberate exemption, which is the whole reason `gstRate` distinguishes
+     * `undefined` from `0`.
+     */
+    findResolvable(id: string): Promise<TaxCodeDocument | null>;
+    /**
+     * Create with a DERIVED id, so the same HSN cannot exist twice.
+     *
+     * Two rows for one HSN is the failure worth preventing structurally: an
+     * admin edits one, categories point at the other, and the rate that reaches
+     * an invoice is whichever the data happens to reference. A 409 here is the
+     * right answer — the request is well-formed and the world already has it.
+     */
+    create(input: TaxCodeCreateInput): Promise<TaxCodeDocument>;
+    update(id: string, data: TaxCodeUpdateInput): Promise<TaxCodeDocument>;
+}
+export declare const taxCodesRepository: TaxCodesRepository;

package/dist/features/tax-codes/repository/tax-codes.repository.js

@@ -0,0 +1,131 @@
+import { normalizeError } from "../../../errors/normalize.js";
+import { DatabaseError, ConflictError, ValidationError } from "../../../errors/index.js";
+import { BaseRepository, } from "../../../providers/db-firebase/index.js";
+import { TAX_CODES_COLLECTION, TAX_CODE_FIELDS, TAX_CODE_SIEVE_FIELDS, createTaxCodeId, isValidHsnCode, } from "../schemas/firestore.js";
+function failureMessage(prefix, error) {
+    return `${prefix}: ${error instanceof Error ? error.message : "Unknown error"}`;
+}
+/**
+ * The `taxCodes` collection.
+ *
+ * Small, read-mostly and read on a hot path — `deriveTaxonomy` resolves a
+ * category's `taxCodeId` on every product create and on any update that names
+ * a taxonomy field. So the two reads below are single-document and
+ * single-field-equality shaped on purpose; neither needs a composite index.
+ */
+export class TaxCodesRepository extends BaseRepository {
+    constructor() {
+        super(TAX_CODES_COLLECTION);
+    }
+    async list(model) {
+        return this.sieveQuery(model, TAX_CODE_SIEVE_FIELDS);
+    }
+    /**
+     * Every active code, chapter-then-rate ordered, for the picker.
+     *
+     * Unpaginated deliberately — this is ~10 rows and will be a few dozen at
+     * most. If it ever needs paging, the picker needs `searchTxt` first, and
+     * that is a different change.
+     */
+    async listActive() {
+        try {
+            const snap = await this.getCollection()
+                .where(TAX_CODE_FIELDS.IS_ACTIVE, "==", true)
+                .get();
+            return snap.docs
+                .map((d) => this.mapDoc(d))
+                .sort((a, b) => (a.chapter ?? "").localeCompare(b.chapter ?? "") ||
+                a.gstRate - b.gstRate ||
+                a.label.localeCompare(b.label));
+        }
+        catch (error) {
+            void normalizeError(error);
+            throw new DatabaseError(failureMessage("Failed to list tax codes", error));
+        }
+    }
+    /**
+     * Every code including inactive ones, for the admin list.
+     *
+     * 🛑 EXPLICITLY bounded, even though the collection is five rows. Two
+     * reasons: `BaseRepository.findAll()` relies on a cap several layers away
+     * (`base.ts` clamps perPage at 500), and a route that reads "all of a
+     * collection" with no visible bound is the shape that has to be re-audited
+     * every time somebody wonders whether it is safe. 200 is far above any
+     * plausible number of HSN codes and far below anything that costs.
+     */
+    async listAllBounded() {
+        try {
+            const snap = await this.getCollection().limit(200).get();
+            return snap.docs
+                .map((d) => this.mapDoc(d))
+                .sort((a, b) => a.label.localeCompare(b.label));
+        }
+        catch (error) {
+            void normalizeError(error);
+            throw new DatabaseError(failureMessage("Failed to list tax codes", error));
+        }
+    }
+    /**
+     * Resolve a code for derivation.
+     *
+     * 🛑 Returns `null` for an INACTIVE code as well as a missing one, and the
+     * caller must treat both the same way: leave the product's `gstRate` and
+     * `hsnCode` alone rather than writing a zero. Deactivating a code must not
+     * silently re-rate the next listing to 0% — that is indistinguishable from a
+     * deliberate exemption, which is the whole reason `gstRate` distinguishes
+     * `undefined` from `0`.
+     */
+    async findResolvable(id) {
+        try {
+            const snap = await this.getCollection().doc(id).get();
+            if (!snap.exists)
+                return null;
+            const doc = this.mapDoc(snap);
+            return doc.isActive ? doc : null;
+        }
+        catch (error) {
+            void normalizeError(error);
+            throw new DatabaseError(failureMessage("Failed to read tax code", error));
+        }
+    }
+    /**
+     * Create with a DERIVED id, so the same HSN cannot exist twice.
+     *
+     * Two rows for one HSN is the failure worth preventing structurally: an
+     * admin edits one, categories point at the other, and the rate that reaches
+     * an invoice is whichever the data happens to reference. A 409 here is the
+     * right answer — the request is well-formed and the world already has it.
+     */
+    async create(input) {
+        const hsn = input.hsnCode?.trim() ?? "";
+        if (hsn !== "" && !isValidHsnCode(hsn)) {
+            throw new ValidationError("An HSN code must be exactly 4, 6 or 8 digits.", { hsnCode: "Must be 4, 6 or 8 digits." });
+        }
+        if (hsn === "" && input.gstRate !== 0) {
+            throw new ValidationError("An HSN code is required for any rate above 0%.", { hsnCode: "Required unless the rate is 0%." });
+        }
+        const id = createTaxCodeId(hsn);
+        const existing = await this.getCollection().doc(id).get();
+        if (existing.exists) {
+            throw new ConflictError(`A tax code for HSN ${hsn || "(exempt)"} already exists. Edit it instead of creating a second one.`);
+        }
+        return this.createWithId(id, { ...input, hsnCode: hsn });
+    }
+    async update(id, data) {
+        /*
+         * 🛑 `hsnCode` is editable but the id is NOT re-derived from it. Changing
+         * the id would orphan every `CategoryProductDefaults.taxCodeId` pointing
+         * here — the mirror-drift shape of Root Cause #42, with an invoice at the
+         * end of it. To correct a wrong HSN: deactivate this row, create the right
+         * one, and repoint the categories.
+         */
+        if (data.hsnCode !== undefined) {
+            const hsn = data.hsnCode.trim();
+            if (hsn !== "" && !isValidHsnCode(hsn)) {
+                throw new ValidationError("An HSN code must be exactly 4, 6 or 8 digits.", { hsnCode: "Must be 4, 6 or 8 digits." });
+            }
+        }
+        return super.update(id, data);
+    }
+}
+export const taxCodesRepository = new TaxCodesRepository();

package/dist/features/tax-codes/schemas/firestore.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Tax codes — Firestore schema
+ *
+ * An HSN code and its GST rate, as an ENTITY rather than two fields repeated
+ * across every category. Changing a rate becomes one edit instead of ~330.
+ *
+ * ## 🛑 The reference is for AUTHORING. The scalars stay for CORRECTNESS.
+ *
+ * `CategoryProductDefaults.taxCodeId` points here, and `deriveTaxonomy`
+ * resolves it to `ProductDocument.gstRate` / `.hsnCode` **on the product**;
+ * the order item then snapshots from the product, exactly as it already does.
+ *
+ * That layering is not redundancy. Without it, editing a tax code would
+ * retroactively change the GST on orders already invoiced — a compliance
+ * problem, not a modelling preference. It is the same reason
+ * `OrderDocumentItem` already snapshots `hsnCode`/`gstRate`.
+ *
+ *   a category edit  -> changes future listings
+ *   a tax-code edit  -> changes future derivations
+ *   nothing          -> rewrites a past sale
+ *
+ * ## Why this exists at all
+ *
+ * GST has never been charged on goods here. Recorded in our own source
+ * (`_internal/server/features/checkout/actions.ts`): *"0 of 40 live orders had
+ * a `gstAmount`, and the order page's Tax row had never rendered."* And
+ * `gstRate` is set on zero of the current products.
+ *
+ * id === slug, prefix "tax-".
+ */
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
+export declare const TAX_CODES_COLLECTION: "taxCodes";
+export declare const TAX_CODE_PREFIX: "tax-";
+/**
+ * The GST slabs. A closed union because a rate outside it is a data error, not
+ * a new option — and because `ProductDocument.gstRate` already declares this
+ * exact set, so a wider type here would not survive the derivation.
+ */
+export type GstRate = 0 | 5 | 12 | 18 | 28;
+export declare const GST_RATE_VALUES: readonly [0, 5, 12, 18, 28];
+/**
+ * HSN chapters this catalogue touches.
+ *
+ * 🛑 Only **9503** is verified. 4911 (printed cards/stickers/posters) and 9504
+ * (playing cards, board games) are the correct chapters for that merchandise
+ * and their CURRENT RATES ARE NOT CONFIRMED — the toys rates themselves moved
+ * in the 2025 revision. Verify before seeding a rate against either, because a
+ * wrong HSN on a real invoice is worse than an absent one.
+ */
+export type HsnChapter = "9503" | "4911" | "9504" | "exempt";
+export interface TaxCodeDocument extends BaseDocument {
+    /** 4, 6 or 8 digits. Empty for the exemption row, which has no HSN. */
+    hsnCode: string;
+    /** Picker label, e.g. "Toys, non-electronic (HSN 9503 0020) — 5%". */
+    label: string;
+    description?: string;
+    gstRate: GstRate;
+    /** Groups the picker. ~10 rows today, more once 4911/9504 are verified. */
+    chapter?: HsnChapter;
+    /**
+     * When the CURRENT rate took effect. Informational — it does NOT rewrite
+     * history, because history lives in the per-product and per-order-item
+     * snapshots. Recorded so an admin can tell a rate that has always been 5%
+     * from one that changed.
+     */
+    effectiveFrom?: Date;
+    isActive: boolean;
+    /** Why this rate, and what it covers — the thing a future admin will want. */
+    notes?: string;
+}
+export type TaxCodeCreateInput = Omit<TaxCodeDocument, "id" | "createdAt" | "updatedAt">;
+export declare const TAX_CODE_UPDATABLE_FIELDS: readonly ["hsnCode", "label", "description", "gstRate", "chapter", "effectiveFrom", "isActive", "notes"];
+export type TaxCodeUpdateInput = Partial<Pick<TaxCodeDocument, (typeof TAX_CODE_UPDATABLE_FIELDS)[number]>>;
+export declare const TAX_CODE_FIELDS: {
+    readonly ID: "id";
+    readonly HSN_CODE: "hsnCode";
+    readonly LABEL: "label";
+    readonly GST_RATE: "gstRate";
+    readonly CHAPTER: "chapter";
+    readonly IS_ACTIVE: "isActive";
+    readonly EFFECTIVE_FROM: "effectiveFrom";
+    readonly CREATED_AT: "createdAt";
+    readonly UPDATED_AT: "updatedAt";
+};
+export declare const TAX_CODE_SIEVE_FIELDS: {
+    readonly label: {
+        readonly canFilter: true;
+        readonly canSort: true;
+    };
+    readonly hsnCode: {
+        readonly canFilter: true;
+        readonly canSort: true;
+    };
+    readonly gstRate: {
+        readonly canFilter: true;
+        readonly canSort: true;
+    };
+    readonly chapter: {
+        readonly canFilter: true;
+        readonly canSort: false;
+    };
+    readonly isActive: {
+        readonly canFilter: true;
+        readonly canSort: false;
+    };
+    readonly createdAt: {
+        readonly canFilter: false;
+        readonly canSort: true;
+    };
+};
+/**
+ * Derive the document id from the HSN code.
+ *
+ * Deterministic, so a seed run is idempotent (Root Cause #25) and so the same
+ * HSN cannot be entered twice under two ids — which would give two rows one
+ * admin edits and the other serves.
+ */
+export declare function createTaxCodeId(hsnCode: string): string;
+/**
+ * India's HSN codes are 4, 6 or 8 digits. Checked rather than trusted because
+ * the inline-create path in the seller form reaches the same route as the
+ * admin editor, and a malformed code propagates onto every product derived
+ * from the category that points at it.
+ */
+export declare function isValidHsnCode(hsnCode: string): boolean;

package/dist/features/tax-codes/schemas/firestore.js

@@ -0,0 +1,82 @@
+/**
+ * Tax codes — Firestore schema
+ *
+ * An HSN code and its GST rate, as an ENTITY rather than two fields repeated
+ * across every category. Changing a rate becomes one edit instead of ~330.
+ *
+ * ## 🛑 The reference is for AUTHORING. The scalars stay for CORRECTNESS.
+ *
+ * `CategoryProductDefaults.taxCodeId` points here, and `deriveTaxonomy`
+ * resolves it to `ProductDocument.gstRate` / `.hsnCode` **on the product**;
+ * the order item then snapshots from the product, exactly as it already does.
+ *
+ * That layering is not redundancy. Without it, editing a tax code would
+ * retroactively change the GST on orders already invoiced — a compliance
+ * problem, not a modelling preference. It is the same reason
+ * `OrderDocumentItem` already snapshots `hsnCode`/`gstRate`.
+ *
+ *   a category edit  -> changes future listings
+ *   a tax-code edit  -> changes future derivations
+ *   nothing          -> rewrites a past sale
+ *
+ * ## Why this exists at all
+ *
+ * GST has never been charged on goods here. Recorded in our own source
+ * (`_internal/server/features/checkout/actions.ts`): *"0 of 40 live orders had
+ * a `gstAmount`, and the order page's Tax row had never rendered."* And
+ * `gstRate` is set on zero of the current products.
+ *
+ * id === slug, prefix "tax-".
+ */
+export const TAX_CODES_COLLECTION = "taxCodes";
+export const TAX_CODE_PREFIX = "tax-";
+export const GST_RATE_VALUES = [0, 5, 12, 18, 28];
+export const TAX_CODE_UPDATABLE_FIELDS = [
+    "hsnCode",
+    "label",
+    "description",
+    "gstRate",
+    "chapter",
+    "effectiveFrom",
+    "isActive",
+    "notes",
+];
+export const TAX_CODE_FIELDS = {
+    ID: "id",
+    HSN_CODE: "hsnCode",
+    LABEL: "label",
+    GST_RATE: "gstRate",
+    CHAPTER: "chapter",
+    IS_ACTIVE: "isActive",
+    EFFECTIVE_FROM: "effectiveFrom",
+    CREATED_AT: "createdAt",
+    UPDATED_AT: "updatedAt",
+};
+export const TAX_CODE_SIEVE_FIELDS = {
+    label: { canFilter: true, canSort: true },
+    hsnCode: { canFilter: true, canSort: true },
+    gstRate: { canFilter: true, canSort: true },
+    chapter: { canFilter: true, canSort: false },
+    isActive: { canFilter: true, canSort: false },
+    createdAt: { canFilter: false, canSort: true },
+};
+/**
+ * Derive the document id from the HSN code.
+ *
+ * Deterministic, so a seed run is idempotent (Root Cause #25) and so the same
+ * HSN cannot be entered twice under two ids — which would give two rows one
+ * admin edits and the other serves.
+ */
+export function createTaxCodeId(hsnCode) {
+    const digits = hsnCode.replace(/\D/g, "");
+    return digits ? `${TAX_CODE_PREFIX}hsn-${digits}` : `${TAX_CODE_PREFIX}exempt-0`;
+}
+/**
+ * India's HSN codes are 4, 6 or 8 digits. Checked rather than trusted because
+ * the inline-create path in the seller form reaches the same route as the
+ * admin editor, and a malformed code propagates onto every product derived
+ * from the category that points at it.
+ */
+export function isValidHsnCode(hsnCode) {
+    return /^(\d{4}|\d{6}|\d{8})$/.test(hsnCode.trim());
+}

package/dist/features/tax-codes/schemas/tax-code-form.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+/** The GST slabs, as the rate select offers them. */
+export declare const GST_RATE_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+/**
+ * Chapter options.
+ *
+ * 🛑 The two non-9503 chapters are offered because the merchandise exists
+ * (printed cards and stickers; playing cards), and their labels say the rate is
+ * unverified rather than implying one. Picking a chapter does not set a rate.
+ */
+export declare const HSN_CHAPTER_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export declare const taxCodeFormSchema: z.ZodEffects<z.ZodObject<{
+    label: z.ZodString;
+    hsnCode: z.ZodOptional<z.ZodString>;
+    gstRate: z.ZodEffects<z.ZodNumber, number, number>;
+    chapter: z.ZodOptional<z.ZodEnum<["9503", "4911", "9504", "exempt"]>>;
+    description: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    isActive: boolean;
+    gstRate: number;
+    description?: string | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+}, {
+    label: string;
+    isActive: boolean;
+    gstRate: number;
+    description?: string | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+}>, {
+    label: string;
+    isActive: boolean;
+    gstRate: number;
+    description?: string | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+}, {
+    label: string;
+    isActive: boolean;
+    gstRate: number;
+    description?: string | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+}>;
+export type TaxCodeFormValues = z.infer<typeof taxCodeFormSchema>;