@eristack/percent 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Eristack contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @eristack/percent
+
+Percent and basis-point ratios as strings — tax, discount, and markup rates without float literals.
+
+```ts
+import { parsePercent, percentOf } from "@eristack/percent";
+
+percentOf("100", parsePercent("10%")); // "10"
+```
+
+Docs: [packages/primitive/percent/docs/index.md](./docs/index.md)

package/dist/core/percent.d.ts

@@ -0,0 +1,16 @@
+import type { Percent, PercentInput } from "./types.js";
+export declare class PercentParseError extends Error {
+    constructor(message: string);
+}
+/** Parse "11%", "0.11", or basis points via PercentInput. */
+export declare function parsePercent(input: PercentInput | string): Percent;
+export declare function fromBasisPoints(bps: string): Percent;
+export declare function fromPercentSymbol(value: string): Percent;
+export declare function toBasisPoints(p: Percent): string;
+export declare function toPercentSymbol(p: Percent): string;
+/** amount * ratio — both decimal strings. */
+export declare function percentOf(amount: string, percent: Percent): string;
+export declare function plusPercent(amount: string, percent: Percent): string;
+export declare function minusPercent(amount: string, percent: Percent): string;
+export declare function addPercents(a: Percent, b: Percent): Percent;
+//# sourceMappingURL=percent.d.ts.map

package/dist/core/percent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"percent.d.ts","sourceRoot":"","sources":["../../src/core/percent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAExD,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AASD,6DAA6D;AAC7D,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,CA8BlE;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAEhD;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,6CAA6C;AAC7C,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAElE;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAEpE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAErE;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAE3D"}

package/dist/core/types.d.ts

@@ -0,0 +1,16 @@
+/** Stored as decimal ratio string (0.11 = 11%). Never use JS float literals. */
+export type PercentValue = string;
+export type Percent = {
+    readonly ratio: PercentValue;
+};
+export type PercentInput = {
+    kind: "ratio";
+    value: string;
+} | {
+    kind: "percent";
+    value: string;
+} | {
+    kind: "basisPoints";
+    value: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/index.cjs

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PercentParseError: () => PercentParseError,
+  addPercents: () => addPercents,
+  fromBasisPoints: () => fromBasisPoints,
+  fromPercentSymbol: () => fromPercentSymbol,
+  minusPercent: () => minusPercent,
+  parsePercent: () => parsePercent,
+  percentOf: () => percentOf,
+  plusPercent: () => plusPercent,
+  toBasisPoints: () => toBasisPoints,
+  toPercentSymbol: () => toPercentSymbol
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/percent.ts
+var import_decimal = __toESM(require("decimal.js"), 1);
+var PercentParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PercentParseError";
+  }
+};
+function normalizeRatio(ratio) {
+  if (ratio.isNegative()) {
+    throw new PercentParseError("Percent ratio cannot be negative");
+  }
+  return { ratio: ratio.toFixed() };
+}
+function parsePercent(input) {
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      throw new PercentParseError("Percent input cannot be empty");
+    }
+    try {
+      if (trimmed.endsWith("%")) {
+        const n = trimmed.slice(0, -1).trim();
+        if (!n) throw new PercentParseError('Percent symbol missing value before "%"');
+        return normalizeRatio(new import_decimal.default(n).div(100));
+      }
+      return normalizeRatio(new import_decimal.default(trimmed));
+    } catch (err) {
+      if (err instanceof PercentParseError) throw err;
+      throw new PercentParseError(`Invalid percent "${input}"`);
+    }
+  }
+  switch (input.kind) {
+    case "ratio":
+      return normalizeRatio(new import_decimal.default(input.value));
+    case "percent":
+      return normalizeRatio(new import_decimal.default(input.value).div(100));
+    case "basisPoints":
+      return normalizeRatio(new import_decimal.default(input.value).div(1e4));
+    default: {
+      const _exhaustive = input;
+      throw new PercentParseError(`Unknown percent input ${String(_exhaustive)}`);
+    }
+  }
+}
+function fromBasisPoints(bps) {
+  return parsePercent({ kind: "basisPoints", value: bps });
+}
+function fromPercentSymbol(value) {
+  return parsePercent({ kind: "percent", value });
+}
+function toBasisPoints(p) {
+  return new import_decimal.default(p.ratio).times(1e4).toFixed(0);
+}
+function toPercentSymbol(p) {
+  return `${new import_decimal.default(p.ratio).times(100).toFixed()}%`;
+}
+function percentOf(amount, percent) {
+  return new import_decimal.default(amount).times(percent.ratio).toFixed();
+}
+function plusPercent(amount, percent) {
+  return new import_decimal.default(amount).times(new import_decimal.default(1).plus(percent.ratio)).toFixed();
+}
+function minusPercent(amount, percent) {
+  return new import_decimal.default(amount).times(new import_decimal.default(1).minus(percent.ratio)).toFixed();
+}
+function addPercents(a, b) {
+  return { ratio: new import_decimal.default(a.ratio).plus(b.ratio).toFixed() };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PercentParseError,
+  addPercents,
+  fromBasisPoints,
+  fromPercentSymbol,
+  minusPercent,
+  parsePercent,
+  percentOf,
+  plusPercent,
+  toBasisPoints,
+  toPercentSymbol
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/core/percent.ts"],"sourcesContent":["export {\n  addPercents,\n  fromBasisPoints,\n  fromPercentSymbol,\n  minusPercent,\n  parsePercent,\n  percentOf,\n  PercentParseError,\n  plusPercent,\n  toBasisPoints,\n  toPercentSymbol,\n} from \"./core/percent.js\";\nexport type { Percent, PercentInput, PercentValue } from \"./core/types.js\";\n","import Decimal from \"decimal.js\";\nimport type { Percent, PercentInput } from \"./types.js\";\n\nexport class PercentParseError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"PercentParseError\";\n  }\n}\n\nfunction normalizeRatio(ratio: Decimal): Percent {\n  if (ratio.isNegative()) {\n    throw new PercentParseError(\"Percent ratio cannot be negative\");\n  }\n  return { ratio: ratio.toFixed() };\n}\n\n/** Parse \"11%\", \"0.11\", or basis points via PercentInput. */\nexport function parsePercent(input: PercentInput | string): Percent {\n  if (typeof input === \"string\") {\n    const trimmed = input.trim();\n    if (!trimmed) {\n      throw new PercentParseError(\"Percent input cannot be empty\");\n    }\n    try {\n      if (trimmed.endsWith(\"%\")) {\n        const n = trimmed.slice(0, -1).trim();\n        if (!n) throw new PercentParseError('Percent symbol missing value before \"%\"');\n        return normalizeRatio(new Decimal(n).div(100));\n      }\n      return normalizeRatio(new Decimal(trimmed));\n    } catch (err) {\n      if (err instanceof PercentParseError) throw err;\n      throw new PercentParseError(`Invalid percent \"${input}\"`);\n    }\n  }\n  switch (input.kind) {\n    case \"ratio\":\n      return normalizeRatio(new Decimal(input.value));\n    case \"percent\":\n      return normalizeRatio(new Decimal(input.value).div(100));\n    case \"basisPoints\":\n      return normalizeRatio(new Decimal(input.value).div(10_000));\n    default: {\n      const _exhaustive: never = input;\n      throw new PercentParseError(`Unknown percent input ${String(_exhaustive)}`);\n    }\n  }\n}\n\nexport function fromBasisPoints(bps: string): Percent {\n  return parsePercent({ kind: \"basisPoints\", value: bps });\n}\n\nexport function fromPercentSymbol(value: string): Percent {\n  return parsePercent({ kind: \"percent\", value });\n}\n\nexport function toBasisPoints(p: Percent): string {\n  return new Decimal(p.ratio).times(10_000).toFixed(0);\n}\n\nexport function toPercentSymbol(p: Percent): string {\n  return `${new Decimal(p.ratio).times(100).toFixed()}%`;\n}\n\n/** amount * ratio — both decimal strings. */\nexport function percentOf(amount: string, percent: Percent): string {\n  return new Decimal(amount).times(percent.ratio).toFixed();\n}\n\nexport function plusPercent(amount: string, percent: Percent): string {\n  return new Decimal(amount).times(new Decimal(1).plus(percent.ratio)).toFixed();\n}\n\nexport function minusPercent(amount: string, percent: Percent): string {\n  return new Decimal(amount).times(new Decimal(1).minus(percent.ratio)).toFixed();\n}\n\nexport function addPercents(a: Percent, b: Percent): Percent {\n  return { ratio: new Decimal(a.ratio).plus(b.ratio).toFixed() };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,qBAAoB;AAGb,IAAM,oBAAN,cAAgC,MAAM;AAAA,EAC3C,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEA,SAAS,eAAe,OAAyB;AAC/C,MAAI,MAAM,WAAW,GAAG;AACtB,UAAM,IAAI,kBAAkB,kCAAkC;AAAA,EAChE;AACA,SAAO,EAAE,OAAO,MAAM,QAAQ,EAAE;AAClC;AAGO,SAAS,aAAa,OAAuC;AAClE,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,UAAU,MAAM,KAAK;AAC3B,QAAI,CAAC,SAAS;AACZ,YAAM,IAAI,kBAAkB,+BAA+B;AAAA,IAC7D;AACA,QAAI;AACF,UAAI,QAAQ,SAAS,GAAG,GAAG;AACzB,cAAM,IAAI,QAAQ,MAAM,GAAG,EAAE,EAAE,KAAK;AACpC,YAAI,CAAC,EAAG,OAAM,IAAI,kBAAkB,yCAAyC;AAC7E,eAAO,eAAe,IAAI,eAAAA,QAAQ,CAAC,EAAE,IAAI,GAAG,CAAC;AAAA,MAC/C;AACA,aAAO,eAAe,IAAI,eAAAA,QAAQ,OAAO,CAAC;AAAA,IAC5C,SAAS,KAAK;AACZ,UAAI,eAAe,kBAAmB,OAAM;AAC5C,YAAM,IAAI,kBAAkB,oBAAoB,KAAK,GAAG;AAAA,IAC1D;AAAA,EACF;AACA,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO,eAAe,IAAI,eAAAA,QAAQ,MAAM,KAAK,CAAC;AAAA,IAChD,KAAK;AACH,aAAO,eAAe,IAAI,eAAAA,QAAQ,MAAM,KAAK,EAAE,IAAI,GAAG,CAAC;AAAA,IACzD,KAAK;AACH,aAAO,eAAe,IAAI,eAAAA,QAAQ,MAAM,KAAK,EAAE,IAAI,GAAM,CAAC;AAAA,IAC5D,SAAS;AACP,YAAM,cAAqB;AAC3B,YAAM,IAAI,kBAAkB,yBAAyB,OAAO,WAAW,CAAC,EAAE;AAAA,IAC5E;AAAA,EACF;AACF;AAEO,SAAS,gBAAgB,KAAsB;AACpD,SAAO,aAAa,EAAE,MAAM,eAAe,OAAO,IAAI,CAAC;AACzD;AAEO,SAAS,kBAAkB,OAAwB;AACxD,SAAO,aAAa,EAAE,MAAM,WAAW,MAAM,CAAC;AAChD;AAEO,SAAS,cAAc,GAAoB;AAChD,SAAO,IAAI,eAAAA,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAM,EAAE,QAAQ,CAAC;AACrD;AAEO,SAAS,gBAAgB,GAAoB;AAClD,SAAO,GAAG,IAAI,eAAAA,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,EAAE,QAAQ,CAAC;AACrD;AAGO,SAAS,UAAU,QAAgB,SAA0B;AAClE,SAAO,IAAI,eAAAA,QAAQ,MAAM,EAAE,MAAM,QAAQ,KAAK,EAAE,QAAQ;AAC1D;AAEO,SAAS,YAAY,QAAgB,SAA0B;AACpE,SAAO,IAAI,eAAAA,QAAQ,MAAM,EAAE,MAAM,IAAI,eAAAA,QAAQ,CAAC,EAAE,KAAK,QAAQ,KAAK,CAAC,EAAE,QAAQ;AAC/E;AAEO,SAAS,aAAa,QAAgB,SAA0B;AACrE,SAAO,IAAI,eAAAA,QAAQ,MAAM,EAAE,MAAM,IAAI,eAAAA,QAAQ,CAAC,EAAE,MAAM,QAAQ,KAAK,CAAC,EAAE,QAAQ;AAChF;AAEO,SAAS,YAAY,GAAY,GAAqB;AAC3D,SAAO,EAAE,OAAO,IAAI,eAAAA,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE;AAC/D;","names":["Decimal"]}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { addPercents, fromBasisPoints, fromPercentSymbol, minusPercent, parsePercent, percentOf, PercentParseError, plusPercent, toBasisPoints, toPercentSymbol, } from "./core/percent.js";
+export type { Percent, PercentInput, PercentValue } from "./core/types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,WAAW,EACX,aAAa,EACb,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,82 @@
+// src/core/percent.ts
+import Decimal from "decimal.js";
+var PercentParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PercentParseError";
+  }
+};
+function normalizeRatio(ratio) {
+  if (ratio.isNegative()) {
+    throw new PercentParseError("Percent ratio cannot be negative");
+  }
+  return { ratio: ratio.toFixed() };
+}
+function parsePercent(input) {
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      throw new PercentParseError("Percent input cannot be empty");
+    }
+    try {
+      if (trimmed.endsWith("%")) {
+        const n = trimmed.slice(0, -1).trim();
+        if (!n) throw new PercentParseError('Percent symbol missing value before "%"');
+        return normalizeRatio(new Decimal(n).div(100));
+      }
+      return normalizeRatio(new Decimal(trimmed));
+    } catch (err) {
+      if (err instanceof PercentParseError) throw err;
+      throw new PercentParseError(`Invalid percent "${input}"`);
+    }
+  }
+  switch (input.kind) {
+    case "ratio":
+      return normalizeRatio(new Decimal(input.value));
+    case "percent":
+      return normalizeRatio(new Decimal(input.value).div(100));
+    case "basisPoints":
+      return normalizeRatio(new Decimal(input.value).div(1e4));
+    default: {
+      const _exhaustive = input;
+      throw new PercentParseError(`Unknown percent input ${String(_exhaustive)}`);
+    }
+  }
+}
+function fromBasisPoints(bps) {
+  return parsePercent({ kind: "basisPoints", value: bps });
+}
+function fromPercentSymbol(value) {
+  return parsePercent({ kind: "percent", value });
+}
+function toBasisPoints(p) {
+  return new Decimal(p.ratio).times(1e4).toFixed(0);
+}
+function toPercentSymbol(p) {
+  return `${new Decimal(p.ratio).times(100).toFixed()}%`;
+}
+function percentOf(amount, percent) {
+  return new Decimal(amount).times(percent.ratio).toFixed();
+}
+function plusPercent(amount, percent) {
+  return new Decimal(amount).times(new Decimal(1).plus(percent.ratio)).toFixed();
+}
+function minusPercent(amount, percent) {
+  return new Decimal(amount).times(new Decimal(1).minus(percent.ratio)).toFixed();
+}
+function addPercents(a, b) {
+  return { ratio: new Decimal(a.ratio).plus(b.ratio).toFixed() };
+}
+export {
+  PercentParseError,
+  addPercents,
+  fromBasisPoints,
+  fromPercentSymbol,
+  minusPercent,
+  parsePercent,
+  percentOf,
+  plusPercent,
+  toBasisPoints,
+  toPercentSymbol
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/percent.ts"],"sourcesContent":["import Decimal from \"decimal.js\";\nimport type { Percent, PercentInput } from \"./types.js\";\n\nexport class PercentParseError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"PercentParseError\";\n  }\n}\n\nfunction normalizeRatio(ratio: Decimal): Percent {\n  if (ratio.isNegative()) {\n    throw new PercentParseError(\"Percent ratio cannot be negative\");\n  }\n  return { ratio: ratio.toFixed() };\n}\n\n/** Parse \"11%\", \"0.11\", or basis points via PercentInput. */\nexport function parsePercent(input: PercentInput | string): Percent {\n  if (typeof input === \"string\") {\n    const trimmed = input.trim();\n    if (!trimmed) {\n      throw new PercentParseError(\"Percent input cannot be empty\");\n    }\n    try {\n      if (trimmed.endsWith(\"%\")) {\n        const n = trimmed.slice(0, -1).trim();\n        if (!n) throw new PercentParseError('Percent symbol missing value before \"%\"');\n        return normalizeRatio(new Decimal(n).div(100));\n      }\n      return normalizeRatio(new Decimal(trimmed));\n    } catch (err) {\n      if (err instanceof PercentParseError) throw err;\n      throw new PercentParseError(`Invalid percent \"${input}\"`);\n    }\n  }\n  switch (input.kind) {\n    case \"ratio\":\n      return normalizeRatio(new Decimal(input.value));\n    case \"percent\":\n      return normalizeRatio(new Decimal(input.value).div(100));\n    case \"basisPoints\":\n      return normalizeRatio(new Decimal(input.value).div(10_000));\n    default: {\n      const _exhaustive: never = input;\n      throw new PercentParseError(`Unknown percent input ${String(_exhaustive)}`);\n    }\n  }\n}\n\nexport function fromBasisPoints(bps: string): Percent {\n  return parsePercent({ kind: \"basisPoints\", value: bps });\n}\n\nexport function fromPercentSymbol(value: string): Percent {\n  return parsePercent({ kind: \"percent\", value });\n}\n\nexport function toBasisPoints(p: Percent): string {\n  return new Decimal(p.ratio).times(10_000).toFixed(0);\n}\n\nexport function toPercentSymbol(p: Percent): string {\n  return `${new Decimal(p.ratio).times(100).toFixed()}%`;\n}\n\n/** amount * ratio — both decimal strings. */\nexport function percentOf(amount: string, percent: Percent): string {\n  return new Decimal(amount).times(percent.ratio).toFixed();\n}\n\nexport function plusPercent(amount: string, percent: Percent): string {\n  return new Decimal(amount).times(new Decimal(1).plus(percent.ratio)).toFixed();\n}\n\nexport function minusPercent(amount: string, percent: Percent): string {\n  return new Decimal(amount).times(new Decimal(1).minus(percent.ratio)).toFixed();\n}\n\nexport function addPercents(a: Percent, b: Percent): Percent {\n  return { ratio: new Decimal(a.ratio).plus(b.ratio).toFixed() };\n}\n"],"mappings":";AAAA,OAAO,aAAa;AAGb,IAAM,oBAAN,cAAgC,MAAM;AAAA,EAC3C,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEA,SAAS,eAAe,OAAyB;AAC/C,MAAI,MAAM,WAAW,GAAG;AACtB,UAAM,IAAI,kBAAkB,kCAAkC;AAAA,EAChE;AACA,SAAO,EAAE,OAAO,MAAM,QAAQ,EAAE;AAClC;AAGO,SAAS,aAAa,OAAuC;AAClE,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,UAAU,MAAM,KAAK;AAC3B,QAAI,CAAC,SAAS;AACZ,YAAM,IAAI,kBAAkB,+BAA+B;AAAA,IAC7D;AACA,QAAI;AACF,UAAI,QAAQ,SAAS,GAAG,GAAG;AACzB,cAAM,IAAI,QAAQ,MAAM,GAAG,EAAE,EAAE,KAAK;AACpC,YAAI,CAAC,EAAG,OAAM,IAAI,kBAAkB,yCAAyC;AAC7E,eAAO,eAAe,IAAI,QAAQ,CAAC,EAAE,IAAI,GAAG,CAAC;AAAA,MAC/C;AACA,aAAO,eAAe,IAAI,QAAQ,OAAO,CAAC;AAAA,IAC5C,SAAS,KAAK;AACZ,UAAI,eAAe,kBAAmB,OAAM;AAC5C,YAAM,IAAI,kBAAkB,oBAAoB,KAAK,GAAG;AAAA,IAC1D;AAAA,EACF;AACA,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO,eAAe,IAAI,QAAQ,MAAM,KAAK,CAAC;AAAA,IAChD,KAAK;AACH,aAAO,eAAe,IAAI,QAAQ,MAAM,KAAK,EAAE,IAAI,GAAG,CAAC;AAAA,IACzD,KAAK;AACH,aAAO,eAAe,IAAI,QAAQ,MAAM,KAAK,EAAE,IAAI,GAAM,CAAC;AAAA,IAC5D,SAAS;AACP,YAAM,cAAqB;AAC3B,YAAM,IAAI,kBAAkB,yBAAyB,OAAO,WAAW,CAAC,EAAE;AAAA,IAC5E;AAAA,EACF;AACF;AAEO,SAAS,gBAAgB,KAAsB;AACpD,SAAO,aAAa,EAAE,MAAM,eAAe,OAAO,IAAI,CAAC;AACzD;AAEO,SAAS,kBAAkB,OAAwB;AACxD,SAAO,aAAa,EAAE,MAAM,WAAW,MAAM,CAAC;AAChD;AAEO,SAAS,cAAc,GAAoB;AAChD,SAAO,IAAI,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAM,EAAE,QAAQ,CAAC;AACrD;AAEO,SAAS,gBAAgB,GAAoB;AAClD,SAAO,GAAG,IAAI,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,EAAE,QAAQ,CAAC;AACrD;AAGO,SAAS,UAAU,QAAgB,SAA0B;AAClE,SAAO,IAAI,QAAQ,MAAM,EAAE,MAAM,QAAQ,KAAK,EAAE,QAAQ;AAC1D;AAEO,SAAS,YAAY,QAAgB,SAA0B;AACpE,SAAO,IAAI,QAAQ,MAAM,EAAE,MAAM,IAAI,QAAQ,CAAC,EAAE,KAAK,QAAQ,KAAK,CAAC,EAAE,QAAQ;AAC/E;AAEO,SAAS,aAAa,QAAgB,SAA0B;AACrE,SAAO,IAAI,QAAQ,MAAM,EAAE,MAAM,IAAI,QAAQ,CAAC,EAAE,MAAM,QAAQ,KAAK,CAAC,EAAE,QAAQ;AAChF;AAEO,SAAS,YAAY,GAAY,GAAqB;AAC3D,SAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE;AAC/D;","names":[]}

package/dist/zod/index.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/zod/index.ts
+var zod_exports = {};
+__export(zod_exports, {
+  percentRatioSchema: () => percentRatioSchema,
+  percentSchema: () => percentSchema
+});
+module.exports = __toCommonJS(zod_exports);
+
+// src/zod/schemas.ts
+var import_zod = require("zod");
+var percentRatioSchema = import_zod.z.string().min(1);
+var percentSchema = import_zod.z.object({
+  ratio: percentRatioSchema
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  percentRatioSchema,
+  percentSchema
+});
+//# sourceMappingURL=index.cjs.map

package/dist/zod/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/zod/index.ts","../../src/zod/schemas.ts"],"sourcesContent":["export {\n  percentRatioSchema,\n  percentSchema,\n  type PercentJson,\n} from \"./schemas.js\";\n","import { z } from \"zod\";\n\n/** Decimal ratio 0–1+ (e.g. \"0.11\" for 11%). */\nexport const percentRatioSchema = z.string().min(1);\n\nexport const percentSchema = z.object({\n  ratio: percentRatioSchema,\n});\n\nexport type PercentJson = z.infer<typeof percentSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,iBAAkB;AAGX,IAAM,qBAAqB,aAAE,OAAO,EAAE,IAAI,CAAC;AAE3C,IAAM,gBAAgB,aAAE,OAAO;AAAA,EACpC,OAAO;AACT,CAAC;","names":[]}

package/dist/zod/index.d.ts

@@ -0,0 +1,2 @@
+export { percentRatioSchema, percentSchema, type PercentJson, } from "./schemas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/zod/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zod/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,KAAK,WAAW,GACjB,MAAM,cAAc,CAAC"}

package/dist/zod/index.js

@@ -0,0 +1,11 @@
+// src/zod/schemas.ts
+import { z } from "zod";
+var percentRatioSchema = z.string().min(1);
+var percentSchema = z.object({
+  ratio: percentRatioSchema
+});
+export {
+  percentRatioSchema,
+  percentSchema
+};
+//# sourceMappingURL=index.js.map

package/dist/zod/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/zod/schemas.ts"],"sourcesContent":["import { z } from \"zod\";\n\n/** Decimal ratio 0–1+ (e.g. \"0.11\" for 11%). */\nexport const percentRatioSchema = z.string().min(1);\n\nexport const percentSchema = z.object({\n  ratio: percentRatioSchema,\n});\n\nexport type PercentJson = z.infer<typeof percentSchema>;\n"],"mappings":";AAAA,SAAS,SAAS;AAGX,IAAM,qBAAqB,EAAE,OAAO,EAAE,IAAI,CAAC;AAE3C,IAAM,gBAAgB,EAAE,OAAO;AAAA,EACpC,OAAO;AACT,CAAC;","names":[]}

package/dist/zod/schemas.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/** Decimal ratio 0–1+ (e.g. "0.11" for 11%). */
+export declare const percentRatioSchema: z.ZodString;
+export declare const percentSchema: z.ZodObject<{
+    ratio: z.ZodString;
+}, z.core.$strip>;
+export type PercentJson = z.infer<typeof percentSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/zod/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/zod/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,gDAAgD;AAChD,eAAO,MAAM,kBAAkB,aAAoB,CAAC;AAEpD,eAAO,MAAM,aAAa;;iBAExB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/docs/_meta.json

@@ -0,0 +1,50 @@
+{
+  "title": "@eristack/percent",
+  "pages": [
+    "index",
+    "getting-started",
+    "concepts",
+    "basis-points",
+    "arithmetic",
+    "zod",
+    "gotchas",
+    "recipes",
+    "api-reference"
+  ],
+  "sections": [
+    {
+      "label": "Start",
+      "pages": [
+        "index",
+        "getting-started"
+      ]
+    },
+    {
+      "label": "Guides",
+      "pages": [
+        "concepts",
+        "basis-points",
+        "arithmetic"
+      ]
+    },
+    {
+      "label": "Adapters",
+      "pages": [
+        "zod"
+      ]
+    },
+    {
+      "label": "Guides",
+      "pages": [
+        "gotchas"
+      ]
+    },
+    {
+      "label": "Reference",
+      "pages": [
+        "recipes",
+        "api-reference"
+      ]
+    }
+  ]
+}

package/docs/api-reference.md

@@ -0,0 +1,37 @@
+# API reference
+
+## Types
+
+| Export | Description |
+| --- | --- |
+| `Percent` | `{ ratio: string }` |
+| `PercentValue` | Ratio string alias |
+| `PercentInput` | Discriminated parse input |
+
+## Parse & construct
+
+| Export | Description |
+| --- | --- |
+| `parsePercent(input)` | String or PercentInput → Percent |
+| `fromBasisPoints(bps)` | bps string → Percent |
+| `fromPercentSymbol(value)` | `"11"` → 11% |
+| `toBasisPoints(p)` | Percent → bps string |
+| `toPercentSymbol(p)` | Display `"11%"` |
+| `PercentParseError` | Invalid/negative input |
+
+## Arithmetic
+
+| Export | Description |
+| --- | --- |
+| `percentOf(amount, percent)` | amount × ratio |
+| `plusPercent(amount, percent)` | amount × (1 + ratio) |
+| `minusPercent(amount, percent)` | amount × (1 − ratio) |
+| `addPercents(a, b)` | Sum ratios |
+
+## Zod (`@eristack/percent/zod`)
+
+| Export | Description |
+| --- | --- |
+| `percentSchema` | `{ ratio }` object |
+| `percentRatioSchema` | Ratio string |
+| `PercentJson` | Inferred type |

package/docs/arithmetic.md

@@ -0,0 +1,51 @@
+# Arithmetic
+
+## percentOf
+
+Line extension before tax:
+
+```ts
+percentOf("250", parsePercent("10%")); // "25"
+```
+
+Both operands are decimal strings; result is decimal string (not rounded currency).
+
+## plusPercent / minusPercent
+
+Gross-up and discount base:
+
+```ts
+plusPercent("100", parsePercent("10%"));  // "110" — add 10%
+minusPercent("100", parsePercent("10%")); // "90"  — subtract 10%
+minusPercent("250", parsePercent("100%")); // "0"   — full write-off of base
+```
+
+`minusPercent` at **100%** zeroes the base string — use before wrapping in `@eristack/money` for credit memos.
+
+## addPercents
+
+Combine component rates only when policy allows simple addition (e.g. stacked surcharges):
+
+```ts
+addPercents(parsePercent("5%"), parsePercent("2%")); // { ratio: "0.07" }
+```
+
+Tax-on-tax and compound discounts need app rules — do not assume `addPercents` matches statutory calculation.
+
+## Order with money rounding
+
+1. Compute line subtotal as string (QUPS / money)
+2. `percentOf(subtotal, taxRate)` → tax string
+3. `Money.of(tax, currency)` + `round` at boundary
+
+Applying percent after float conversion defeats the purpose of this package.
+
+## toPercentSymbol
+
+Display only:
+
+```ts
+toPercentSymbol(parsePercent("0.11")); // "11%"
+```
+
+Do not parse display strings back from formatted UI without user intent.

package/docs/basis-points.md

@@ -0,0 +1,41 @@
+# Basis points
+
+Finance and ERP tables often store **basis points (bps)** — 1 bps = 0.01%.
+
+| Display | bps | ratio |
+| --- | --- | --- |
+| 11.00% | `1100` | `0.11` |
+| 7.50% | `750` | `0.075` |
+| 0.125% | `12.5` → use string `12.5` or store ratio | `0.00125` |
+
+## API
+
+```ts
+import { fromBasisPoints, toBasisPoints, parsePercent } from "@eristack/percent";
+
+fromBasisPoints("1100"); // { ratio: "0.11" }
+toBasisPoints(parsePercent("11%")); // "1100"
+```
+
+## Drizzle column
+
+Store bps as `numeric` or text in SQL; read as string into `fromBasisPoints`:
+
+```ts
+const rate = fromBasisPoints(row.vatBps);
+```
+
+## Precision
+
+`toBasisPoints` uses `toFixed(0)` — suitable for whole bps. Sub-bps precision: store ratio string directly instead of bps.
+
+## VAT / withholding tables
+
+```ts
+const rates = {
+  standard: fromBasisPoints("2000"), // 20%
+  reduced: fromBasisPoints("550"),   // 5.5%
+};
+```
+
+Keep table in app DB; percent package only parses/applies.

package/docs/concepts.md

@@ -0,0 +1,40 @@
+# Concepts
+
+## Stored form: ratio
+
+Internally `Percent` is `{ ratio: string }` where ratio is a decimal:
+
+| Meaning | ratio string |
+| --- | --- |
+| 11% | `"0.11"` |
+| 7.5% | `"0.075"` |
+| 100% | `"1"` |
+
+Never store `11` meaning 11% without parsing — use `parsePercent("11%")` or `fromBasisPoints`.
+
+## Input kinds
+
+```ts
+parsePercent("11%");                                    // percent symbol
+parsePercent("0.11");                                   // raw ratio
+parsePercent({ kind: "basisPoints", value: "1100" });   // bps
+parsePercent({ kind: "percent", value: "11" });
+parsePercent({ kind: "ratio", value: "0.11" });
+```
+
+## vs @eristack/money percent helpers
+
+| Use | Package |
+| --- | --- |
+| Rate is master data / tax code | `@eristack/percent` |
+| Apply known % to `Money` with currency | `@eristack/money` `percentOf` |
+
+Typical flow: `percentOf(lineAmount, taxRate)` on strings → wrap in `Money.of` → round at ledger.
+
+## Immutability
+
+`Percent` objects are plain data — create new via `parsePercent` / `fromBasisPoints`; `addPercents` returns new ratio.
+
+## Negative rates
+
+Parsing rejects negative ratios. Credits/reversals use positive rate + app sign on amount.

package/docs/getting-started.md

@@ -0,0 +1,50 @@
+# Getting started
+
+Parse and apply tax/discount rates without float literals.
+
+## Install
+
+```bash
+pnpm add @eristack/percent
+```
+
+## Parse rates
+
+```ts
+import { parsePercent, fromBasisPoints, percentOf } from "@eristack/percent";
+
+parsePercent("11%");              // { ratio: "0.11" }
+fromBasisPoints("1100");          // { ratio: "0.11" }
+parsePercent({ kind: "ratio", value: "0.075" }); // 7.5%
+```
+
+## Apply to amounts
+
+```ts
+const vat = parsePercent("10%");
+percentOf("100", vat);   // "10"
+plusPercent("100", vat); // "110"
+minusPercent("100", vat); // "90"
+```
+
+Round with `@eristack/money` at invoice boundaries after percent math on strings.
+
+## Zod
+
+```ts
+import { percentSchema } from "@eristack/percent/zod";
+
+percentSchema.parse({ ratio: "0.11" });
+```
+
+## Production path
+
+1. Store rates in master data as basis points or ratio strings.
+2. Parse with `@eristack/percent` at API boundary.
+3. Pass ratio into QUPS modifiers or money operators after line calculation.
+
+## Next
+
+- [Basis points](./basis-points.md) — finance tables
+- [Arithmetic](./arithmetic.md) — combining rates
+- [Recipes](./recipes.md) — tax line, stacked discount

package/docs/gotchas.md

@@ -0,0 +1,32 @@
+# Gotchas
+
+## Double scaling
+
+```ts
+percentOf("100", parsePercent("0.11")); // wrong if user meant 11%
+percentOf("100", parsePercent("11%"));  // correct
+```
+
+## Mixing money Percent and this package
+
+`@eristack/money` `percentOf(money, "7")` means **7 percent points**. `@eristack/percent` stores ratio `0.07`. Convert explicitly.
+
+## Compound tax
+
+`addPercents` is not compound tax (11% + 5% on top of taxed amount). Implement compound rules in app.
+
+## Empty and malformed input
+
+`parsePercent("")`, `parsePercent("%")`, and `parsePercent("abc%")` throw **`PercentParseError`** with a clear message — not raw Decimal errors.
+
+```ts
+parsePercent(0.11); // wrong type — use string
+```
+
+## Rounding direction
+
+percent package does not apply banker's rounding — delegate to `@eristack/money` `Rounding` at invoice total.
+
+## Rates over 100%
+
+Ratio `"1.5"` (150%) parses if non-negative — allow in surcharge scenarios; reject in UI if business forbids.

package/docs/index.md

@@ -0,0 +1,40 @@
+---
+title: "@eristack/percent"
+description: Percent and basis-point ratios as strings for tax and discounts
+sidebar_position: 1
+---
+
+# @eristack/percent
+
+`@eristack/percent` stores **rates and ratios as decimal strings** — `"0.11"` for 11%, basis points `"1100"` for 11.00% — so tax, discount, and markup math never touches JS float literals. Complements `@eristack/money` (amounts) and `@eristack/qups` (line calculators).
+
+## When to use it
+
+Use this package when you need:
+
+- Parse `"11%"`, `"0.11"`, or basis points from ERP master data
+- `percentOf`, `plusPercent`, `minusPercent` on string amounts before rounding with `@eristack/money`
+- Serializable `{ ratio }` JSON for API contracts
+- Zod 4 validation for percent fields
+
+## Relationship to @eristack/money
+
+`@eristack/money` includes `percentOf` on `Money` for **currency-safe** totals after you know the rate. Use `@eristack/percent` when the rate itself is the domain value (tax codes, tier tables, QUPS modifiers) and you want a dedicated ratio type.
+
+## Subpaths
+
+```text
+@eristack/percent                    core — parsePercent, fromBasisPoints, percentOf
+        └── /zod                     percentSchema (peer zod ^4)
+```
+
+## Next steps
+
+- [Getting started](./getting-started.md) — parse, apply to line amount
+- [Concepts](./concepts.md) — ratio vs percent symbol vs bps
+- [Basis points](./basis-points.md) — finance rates, VAT tables
+- [Arithmetic](./arithmetic.md) — percentOf, plus/minus, combining rates
+- [Zod](./zod.md) — wire validation
+- [Gotchas](./gotchas.md) — double-scaling, negative rates, money rounding order
+- [Recipes](./recipes.md) — tax line, stacked discount, QUPS modifier
+- [API reference](./api-reference.md) — exports cheat-sheet

package/docs/recipes.md

@@ -0,0 +1,44 @@
+# Recipes
+
+## Invoice VAT line
+
+```ts
+import { parsePercent, percentOf } from "@eristack/percent";
+import { Money } from "@eristack/money";
+
+const vat = parsePercent({ kind: "basisPoints", value: row.vatBps });
+const taxStr = percentOf(subtotal.toDecimal(), vat);
+const tax = Money.of(taxStr, subtotal.currency);
+```
+
+## Header discount
+
+```ts
+import { minusPercent, parsePercent } from "@eristack/percent";
+
+const discounted = minusPercent(lineTotal, parsePercent("15%"));
+```
+
+## QUPS modifier rate
+
+Pass ratio string into modifier config; parse once at document load:
+
+```ts
+const modifierRate = parsePercent(taxCode.rate); // "10%" from master
+// apply in line calculator before money wrap
+```
+
+## API: accept human input
+
+```ts
+const rate = parsePercent(req.body.rateLabel); // "7.5%"
+await db.update(taxCodes).set({ ratio: rate.ratio });
+```
+
+## Display bps in admin grid
+
+```ts
+import { toBasisPoints, parsePercent } from "@eristack/percent";
+
+toBasisPoints(parsePercent(row.ratio)); // show in grid column
+```

package/docs/zod.md

@@ -0,0 +1,20 @@
+# Zod
+
+Peer `zod ^4`.
+
+```bash
+pnpm add @eristack/percent @eristack/percent/zod zod
+```
+
+```ts
+import { percentSchema, percentRatioSchema } from "@eristack/percent/zod";
+
+percentSchema.parse({ ratio: "0.11" });
+percentRatioSchema.parse("0.075");
+```
+
+Validate shape on wire JSON; use `parsePercent` for `"11%"` human input forms.
+
+## Type
+
+`PercentJson` — `{ ratio: string }` for OpenAPI schemas.

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@eristack/percent",
+  "version": "0.1.1",
+  "description": "Percent and basis-point ratios as strings — tax, discount, markup without float literals",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eristack/business-libs.git",
+    "directory": "packages/primitive/percent"
+  },
+  "homepage": "https://github.com/eristack/business-libs/tree/main/packages/primitive/percent",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./zod": {
+      "import": {
+        "types": "./dist/zod/index.d.ts",
+        "default": "./dist/zod/index.js"
+      },
+      "require": {
+        "types": "./dist/zod/index.d.ts",
+        "default": "./dist/zod/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "docs",
+    "README.md",
+    "skills",
+    "LICENSE"
+  ],
+  "keywords": [
+    "tanstack-intent",
+    "percent",
+    "basis-points",
+    "tax",
+    "discount",
+    "eristack"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "decimal.js": "^10.6.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@tanstack/intent": "^0.3.6",
+    "@types/node": "^22.15.29",
+    "tsup": "^8.5.0",
+    "typescript": "^7.0.0",
+    "vitest": "^4.1.10",
+    "zod": "^4.0.0"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.build.json",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  }
+}

package/skills/percent-core/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: percent-core
+description: >
+  @eristack/percent ratio strings, basis points, percentOf/plus/minus for tax and
+  discounts without float literals. Use before @eristack/money rounding at boundaries.
+metadata:
+  author: eristack
+  version: "0.1"
+sources:
+  - packages/primitive/percent/docs/index.md
+---
+
+# @eristack/percent
+
+Rates as **decimal ratio strings** — `"0.11"` for 11%, basis points `"1100"`.
+
+```ts
+import { parsePercent, percentOf, fromBasisPoints } from "@eristack/percent";
+
+const vat = parsePercent("10%");
+percentOf("100", vat); // "10"
+fromBasisPoints("1100"); // 11%
+```
+
+## Checklist
+
+1. Master data: store bps or ratio string — parse with `parsePercent` / `fromBasisPoints`.
+2. Line math on strings; wrap in `@eristack/money` + round at invoice/ledger boundary.
+3. Do not confuse with money `percentOf(m, "7")` (7 percent points) — convert ratio explicitly.
+4. Compound tax/discount stacks are **app rules** — `addPercents` is simple sum only.
+5. Validate wire JSON with `@eristack/percent/zod`; human `"11%"` input via `parsePercent`.
+
+## Do not
+
+- Pass JS float literals (`0.11`) as domain rates
+- Assume statutory compound tax from `addPercents` alone