@butinapp/sdk 0.1.0

package/dist/testing/synthetic.js

@@ -0,0 +1,259 @@
+// Seeded, zero-dependency synthetic data for the demo seed + sample contract tests. A plugin's `sample`
+// generator builds its raw payload ONLY from this toolkit, so the demo can never carry a real name, email,
+// address, or account number — there is no literal to paste one into. Deterministic (no Math.random/Date.now):
+// a constant reference instant + a per-call seeded PRNG → byte-identical re-runs.
+import { MS_PER_DAY } from '../util/date.js';
+// xfnv1a → mulberry32: the same tiny PRNG core's seed uses, kept private here (the SDK can't import core).
+const hashSeed = (s) => {
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+};
+const mulberry32 = (seed) => {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+};
+const FIRST_NAMES = [
+    'Liam',
+    'Emma',
+    'Owen',
+    'Chloe',
+    'Connor',
+    'Hannah',
+    'Ethan',
+    'Olivia',
+    'Nathan',
+    'Sophie',
+    'Lucas',
+    'Grace',
+    'Ryan',
+    'Megan',
+    'Aiden',
+    'Ella'
+];
+const LAST_NAMES = [
+    'MacDonald',
+    'Brennan',
+    'Murphy',
+    'Walsh',
+    'Kelly',
+    'Campbell',
+    'Thompson',
+    'Clarke',
+    'Sullivan',
+    'Fitzgerald',
+    'Cohen',
+    'Goldberg',
+    'Russo',
+    'Bianchi',
+    'Pappas',
+    'Ryan'
+];
+const COMPANY_A = ['Northwind', 'Globex', 'Initech', 'Umbrella', 'Acme', 'Hooli', 'Vandelay', 'Soylent'];
+const COMPANY_B = ['Systems', 'Labs', 'Industries', 'Group', 'Cloud', 'Works'];
+const SLUGS = ['acme', 'northwind', 'globex', 'initech', 'umbrella', 'hooli', 'vandelay'];
+const LOREM = [
+    'lorem',
+    'ipsum',
+    'dolor',
+    'sit',
+    'amet',
+    'consectetur',
+    'adipiscing',
+    'elit',
+    'sed',
+    'tempor',
+    'incididunt',
+    'labore',
+    'magna',
+    'aliqua',
+    'veniam',
+    'nostrud',
+    'aliquip',
+    'commodo',
+    'dataset',
+    'metric',
+    'report',
+    'usage',
+    'invoice',
+    'service'
+];
+const STREETS = ['Maple', 'Cedar', 'Oak', 'Exemple', 'River', 'Hill', 'Birch', 'Pine'];
+const CITIES = ['Montréal', 'Québec', 'Laval', 'Gatineau', 'Sherbrooke'];
+// Canada Post's valid letter set (excludes D F I O Q U / W Z). Postals are RANDOMIZED per call, never a fixed
+// pool — a constant code would be a real FSA tied to a real neighbourhood.
+const POSTAL_LETTERS = [
+    'A',
+    'B',
+    'C',
+    'E',
+    'G',
+    'H',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'P',
+    'R',
+    'S',
+    'T',
+    'V',
+    'X',
+    'Y'
+];
+const MONTH_NAMES = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December'
+];
+// A fixed-size cast built once from a CONSTANT root seed — identical across every plugin + every run, so the
+// same fabricated person recurs across services. Index emails to guarantee uniqueness; all `@example.invalid`.
+const CAST_SIZE = 64;
+let castMemo;
+const buildCast = () => {
+    if (castMemo) {
+        return castMemo;
+    }
+    const r = mulberry32(hashSeed('butin-sample-cast'));
+    castMemo = Array.from({ length: CAST_SIZE }, (_, i) => {
+        const firstName = FIRST_NAMES[Math.floor(r() * FIRST_NAMES.length)];
+        const lastName = LAST_NAMES[Math.floor(r() * LAST_NAMES.length)];
+        return {
+            id: `usr_${String(i + 1).padStart(4, '0')}`,
+            firstName,
+            lastName,
+            name: `${firstName} ${lastName}`,
+            email: `${firstName}.${lastName}.${i}@example.invalid`.toLowerCase()
+        };
+    });
+    return castMemo;
+};
+// A deterministic unique person for an index beyond the shared cast — lets a large roster (xlarge) hold more
+// than CAST_SIZE distinct members without repeating. Indices < CAST_SIZE stay the stable shared cast.
+const personBeyondCast = (i) => {
+    const firstName = FIRST_NAMES[i % FIRST_NAMES.length];
+    const lastName = LAST_NAMES[(Math.floor(i / FIRST_NAMES.length) + i) % LAST_NAMES.length];
+    return {
+        id: `usr_${String(i + 1).padStart(4, '0')}`,
+        firstName,
+        lastName,
+        name: `${firstName} ${lastName}`,
+        email: `${firstName}.${lastName}.${i}@example.invalid`.toLowerCase()
+    };
+};
+// A fixed instant the relative dates are measured from — never Date.now (which would break reproducibility).
+const REFERENCE_MS = Date.UTC(2026, 5, 17, 12, 0, 0);
+const MIDNIGHT_REF_MS = Date.UTC(2026, 5, 17, 0, 0, 0); // midnight of the reference day, for epoch/day helpers
+const REF_YEAR = 2026;
+const REF_MONTH0 = 5; // June (0-based), the reference month for monthsAgo
+export const createSampleGen = (seed) => {
+    const rng = mulberry32(hashSeed(seed));
+    const cast = buildCast();
+    const int = (min, max) => Math.floor(min + rng() * (max - min + 1));
+    const pick = (items) => items[Math.floor(rng() * items.length)];
+    const last4 = () => String(int(1000, 9999));
+    const pastDate = (maxDaysAgo) => new Date(REFERENCE_MS - int(0, Math.max(0, maxDaysAgo)) * MS_PER_DAY).toISOString();
+    const dayMs = (maxDaysAgo) => MIDNIGHT_REF_MS - int(0, Math.max(0, maxDaysAgo)) * MS_PER_DAY;
+    const day = (maxDaysAgo) => {
+        const ms = dayMs(maxDaysAgo);
+        const iso = new Date(ms).toISOString();
+        return { date: iso.slice(0, 10), iso, epochMs: ms, epochSec: Math.floor(ms / 1000), yearMonth: iso.slice(0, 7) };
+    };
+    const onePerson = () => {
+        const firstName = pick(FIRST_NAMES);
+        const lastName = pick(LAST_NAMES);
+        return {
+            id: `usr_${Math.floor(rng() * 0xffffffff).toString(36)}`,
+            firstName,
+            lastName,
+            name: `${firstName} ${lastName}`,
+            email: `${firstName}.${lastName}.${int(100, 999)}@example.invalid`.toLowerCase()
+        };
+    };
+    const gen = {
+        person: (i) => (i === undefined ? onePerson() : cast[((i % CAST_SIZE) + CAST_SIZE) % CAST_SIZE]),
+        people: (n) => Array.from({ length: Math.max(0, n) }, (_, i) => (i < CAST_SIZE ? cast[i] : personBeyondCast(i))),
+        company: () => `${pick(COMPANY_A)} ${pick(COMPANY_B)}`,
+        orgSlug: () => pick(SLUGS),
+        id: (prefix = 'id') => `${prefix}_${Math.floor(rng() * 0xffffffff).toString(36)}`,
+        int,
+        float: (min, max, decimals = 2) => {
+            const p = 10 ** decimals;
+            return Math.round((min + rng() * (max - min)) * p) / p;
+        },
+        bool: (p = 0.5) => rng() < p,
+        pick,
+        maybe: (value, p = 0.5) => (rng() < p ? value : undefined),
+        money: (min, max) => Math.round((min + rng() * (max - min)) * 100) / 100,
+        amountCents: (min, max) => Math.floor(min + rng() * (max - min)),
+        pastDate,
+        dayString: (maxDaysAgo) => pastDate(maxDaysAgo).slice(0, 10),
+        words: (n) => Array.from({ length: Math.max(0, n) }, () => pick(LOREM)).join(' '),
+        sentence: () => {
+            const w = Array.from({ length: int(4, 9) }, () => pick(LOREM));
+            return `${w[0].charAt(0).toUpperCase()}${w[0].slice(1)} ${w.slice(1).join(' ')}.`;
+        },
+        maskedKey: () => `…${last4()}`,
+        last4,
+        phone: () => `555-01${int(10, 99)}`,
+        postal: () => `${pick(POSTAL_LETTERS)}${int(0, 9)}${pick(POSTAL_LETTERS)} ${int(0, 9)}${pick(POSTAL_LETTERS)}${int(0, 9)}`,
+        address: () => `${int(1, 9999)} rue ${pick(STREETS)}, ${pick(CITIES)} (Québec) ${gen.postal()}`,
+        day,
+        midnightIso: (maxDaysAgo) => day(maxDaysAgo).iso,
+        pastEpochMs: (maxDaysAgo) => dayMs(maxDaysAgo),
+        pastEpochSec: (maxDaysAgo) => Math.floor(dayMs(maxDaysAgo) / 1000),
+        monthsAgo: (n) => {
+            const total = REF_YEAR * 12 + REF_MONTH0 - n;
+            const y = Math.floor(total / 12);
+            const m0 = ((total % 12) + 12) % 12;
+            const startEpochMs = Date.UTC(y, m0, 1, 0, 0, 0);
+            const mm = String(m0 + 1).padStart(2, '0');
+            return {
+                yearMonth: `${y}-${mm}`,
+                ym: `${y}${mm}`,
+                startEpochMs,
+                startEpochSec: Math.floor(startEpochMs / 1000),
+                label: `${MONTH_NAMES[m0]} ${y}`
+            };
+        },
+        url: (segment, id) => `https://example.invalid/${segment}${id === undefined ? '' : `/${id}`}`,
+        moneyStr: (min, max, decimals = 2) => (min + rng() * (max - min)).toFixed(decimals),
+        seqId: (prefix, n, width = 4) => `${prefix}${String(n).padStart(width, '0')}`,
+        repeat: (n, fn) => Array.from({ length: Math.max(0, n) }, (_, i) => fn(i, gen))
+    };
+    return gen;
+};
+const SAMPLE_PRESETS = {
+    small: { users: 3, documents: 5, days: 14, window: 60 },
+    medium: { users: 12, documents: 20, days: 30, window: 180 },
+    large: { users: 40, documents: 60, days: 120, window: 365 },
+    xlarge: { users: 400, documents: 130, days: 250, window: 365 }
+};
+// Preset (default medium) then apply only the explicitly-provided knobs. medium === today's seed defaults.
+export const resolveSampleConfig = (input) => {
+    const base = SAMPLE_PRESETS[input?.size ?? 'medium'];
+    return {
+        users: input?.users ?? base.users,
+        documents: input?.documents ?? base.documents,
+        days: input?.days ?? base.days,
+        window: input?.window ?? base.window
+    };
+};

package/dist/util/date.d.ts

@@ -0,0 +1,14 @@
+export declare const MS_PER_DAY = 86400000;
+export declare const MONTH_ABBR: string[];
+export declare const setReportingZone: (zone: string) => void;
+export declare const getReportingZone: () => string;
+export declare const isoDay: (value?: string | null) => string | undefined;
+export declare const epochMsDay: (ms?: number | null) => string | undefined;
+export declare const epochSecDay: (seconds?: number | null) => string | undefined;
+export declare const dayOf: (value?: string | null) => string | undefined;
+export declare const monthKey: (year: number, month: number) => string;
+export declare const currentMonthKey: (now?: Date) => string;
+export declare const dayMinus: (day: string, days: number) => string;
+export declare const utcDaysAgo: (days: number) => string;
+export declare const isoDaysAgo: (days: number, now?: Date) => string;
+export declare const monthStart: (now?: Date) => string;

package/dist/util/date.js

@@ -0,0 +1,49 @@
+import { DateTime } from '../libs.js';
+// Date→string helpers shared across plugins. Vendors hand us ISO datetimes, epoch ms, or epoch seconds;
+// the data-view contract wants plain 'YYYY-MM-DD' day keys. Normalize at the edge here so each plugin's
+// build*() stays free of ad-hoc date slicing.
+// Milliseconds in a calendar day — the shared unit for day-arithmetic across plugins, core, and the UI.
+export const MS_PER_DAY = 86_400_000;
+// English short month names, indexed by 0-based month — the compact 'Jan'…'Dec' labels for month-keyed series.
+export const MONTH_ABBR = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+// The single timezone every day/month BUCKET is computed in — so "this month", a per-day series, and the values
+// each plugin books all agree on where the boundary sits. Defaults to 'utc' so the pure helpers (and every plugin
+// fixture that asserts a day) stay deterministic regardless of the test runner's OS zone; the running app calls
+// setReportingZone with the OS zone at boot, so buckets follow the user's wall clock and roll at their local
+// midnight. An IANA name ('America/New_York'), 'system', or 'utc'.
+let reportingZone = 'utc';
+export const setReportingZone = (zone) => {
+    reportingZone = zone;
+};
+export const getReportingZone = () => reportingZone;
+// Trim an ISO datetime string to its 'YYYY-MM-DD' day, keeping the day AS WRITTEN (no zone conversion) — for a
+// vendor field that is already the intended calendar day. To bucket a real instant into the reporting zone, use
+// `dayOf`/`epochMsDay`. Empty/missing → undefined.
+export const isoDay = (value) => (value ? value.slice(0, 10) : undefined);
+// Epoch milliseconds → 'YYYY-MM-DD' in the reporting zone. 0/missing/invalid → undefined.
+export const epochMsDay = (ms) => {
+    if (!ms) {
+        return undefined;
+    }
+    const d = DateTime.fromMillis(ms, { zone: reportingZone });
+    return d.isValid ? d.toISODate() : undefined;
+};
+// Epoch seconds → reporting-zone 'YYYY-MM-DD' (most token/activity APIs report seconds). 0/missing/invalid → undefined.
+export const epochSecDay = (seconds) => epochMsDay(seconds == null ? undefined : seconds * 1000);
+// ISO datetime (Z or tz-offset) → its 'YYYY-MM-DD' day in the reporting zone. Reparses through the instant so an
+// offset datetime lands on the correct zoned day, where the slice-based `isoDay` would keep the day as written.
+// Missing/unparseable → undefined.
+export const dayOf = (value) => epochMsDay(value ? Date.parse(value) : undefined);
+// 'YYYY-MM' month key from a 1-based month.
+export const monthKey = (year, month) => `${year}-${String(month).padStart(2, '0')}`;
+// 'YYYY-MM' month key of `now` in the reporting zone — the current calendar month.
+export const currentMonthKey = (now = new Date()) => DateTime.fromJSDate(now, { zone: reportingZone }).toFormat('yyyy-MM');
+// 'YYYY-MM-DD' for `days` before `day` (a UTC 'YYYY-MM-DD'). Day-string arithmetic goes through luxon, so callers
+// never re-roll millisecond math; invalid input returns `day` unchanged.
+export const dayMinus = (day, days) => DateTime.fromISO(day, { zone: 'utc' }).minus({ days }).toISODate() ?? day;
+// UTC 'YYYY-MM-DD' for N days before now.
+export const utcDaysAgo = (days) => new Date(Date.now() - days * MS_PER_DAY).toISOString().slice(0, 10);
+// Full UTC ISO datetime N days before `now` — the start of a since-window passed to usage/event APIs.
+export const isoDaysAgo = (days, now = new Date()) => new Date(now.getTime() - days * MS_PER_DAY).toISOString();
+// First day of `now`'s month in the reporting zone, as 'YYYY-MM-DD'.
+export const monthStart = (now = new Date()) => DateTime.fromJSDate(now, { zone: reportingZone }).startOf('month').toISODate();

package/dist/util/fx.d.ts

@@ -0,0 +1,2 @@
+export type FxRates = Record<string, number>;
+export declare const convert: (amount: number, from: string, to: string, rates: FxRates) => number | null;

package/dist/util/fx.js

@@ -0,0 +1,7 @@
+export const convert = (amount, from, to, rates) => {
+    if (from === to) {
+        return amount;
+    }
+    const rate = rates[from];
+    return rate === undefined ? null : amount * rate;
+};

package/dist/util/index.d.ts

@@ -0,0 +1,6 @@
+export { centsToMajor, centsStringToMajor, millicentsToMajor, parseDecimalAmount, round2, parseFrAmount } from './money.js';
+export { isoDay, dayOf, epochMsDay, epochSecDay, monthKey, currentMonthKey, dayMinus, utcDaysAgo, isoDaysAgo, monthStart, getReportingZone, setReportingZone, MS_PER_DAY, MONTH_ABBR } from './date.js';
+export { startCase, parseDollarAmount } from './text.js';
+export { convert } from './fx.js';
+export type { FxRates } from './fx.js';
+export { omitUndef, asArray } from './object.js';

package/dist/util/index.js

@@ -0,0 +1,9 @@
+// @butinapp/sdk/util — Butin's own edge normalizers: unit conversion (cents/millicents/decimal → major
+// units), reporting-zone day/month helpers, title-casing + amount parsing, currency conversion. Flat named exports —
+// their leaf names already read clearly, and a namespace prefix would shadow common locals (`date`, `fx`).
+// (Generic third-party utilities — lodash + luxon — live on @butinapp/sdk/libs.)
+export { centsToMajor, centsStringToMajor, millicentsToMajor, parseDecimalAmount, round2, parseFrAmount } from './money.js';
+export { isoDay, dayOf, epochMsDay, epochSecDay, monthKey, currentMonthKey, dayMinus, utcDaysAgo, isoDaysAgo, monthStart, getReportingZone, setReportingZone, MS_PER_DAY, MONTH_ABBR } from './date.js';
+export { startCase, parseDollarAmount } from './text.js';
+export { convert } from './fx.js';
+export { omitUndef, asArray } from './object.js';

package/dist/util/money.d.ts

@@ -0,0 +1,6 @@
+export declare const centsToMajor: (value?: number | null) => number;
+export declare const centsStringToMajor: (value?: string) => number;
+export declare const millicentsToMajor: (value?: string) => number;
+export declare const parseDecimalAmount: (value?: string) => number;
+export declare const round2: (n: number) => number;
+export declare const parseFrAmount: (raw?: string | null) => number;

package/dist/util/money.js

@@ -0,0 +1,35 @@
+// Money-unit converters — vendors report in cents / cent-strings / millicents / decimal-strings.
+// Normalize everything to MAJOR UNITS of the value's own currency at the edge; the currency itself is
+// named separately by `reportingCurrency` / a Column's `currency`. Unit conversion, not currency conversion.
+const CENTS_PER_MAJOR = 100;
+const MILLICENTS_PER_MAJOR = 100_000;
+export const centsToMajor = (value) => (value ?? 0) / CENTS_PER_MAJOR;
+export const centsStringToMajor = (value) => (value ? parseInt(value, 10) / CENTS_PER_MAJOR : 0);
+export const millicentsToMajor = (value) => {
+    const n = value ? parseInt(value, 10) : 0;
+    return Number.isFinite(n) ? n / MILLICENTS_PER_MAJOR : 0;
+};
+export const parseDecimalAmount = (value) => {
+    if (!value) {
+        return 0;
+    }
+    const n = parseFloat(value.replace(/[^0-9.-]/g, ''));
+    return Number.isFinite(n) ? n : 0;
+};
+// Round to 2 decimals — sheds the float noise a vendor's already-major-unit amount carries (69.90000001 → 69.9).
+export const round2 = (n) => Math.round(n * 100) / 100;
+// French-Canadian money string → major units, rounded to cents. Handles space thousands-seps, a `$` suffix, and a
+// comma decimal ("24 716,80 $" | "1 234,56 $" → 24716.8 | 1234.56), while still parsing dot-decimal ("1,234.56").
+// A bare comma-decimal (no dot present) is treated as the decimal point; otherwise commas are thousands-seps and
+// dropped. 0 when empty or unparseable. (parseDecimalAmount drops commas wholesale, so it can't read the fr form.)
+export const parseFrAmount = (raw) => {
+    if (!raw) {
+        return 0;
+    }
+    const cleaned = raw.replace(/\s/g, '').replace(/\$/g, '');
+    const normalized = cleaned.includes(',') && !cleaned.includes('.')
+        ? cleaned.replace(/\./g, '').replace(',', '.')
+        : cleaned.replace(/,/g, '');
+    const n = parseFloat(normalized);
+    return Number.isFinite(n) ? round2(n) : 0;
+};

package/dist/util/object.d.ts

@@ -0,0 +1,2 @@
+export declare const omitUndef: <T extends object>(o: T) => T;
+export declare const asArray: <T>(value: unknown) => T[];

package/dist/util/object.js

@@ -0,0 +1,7 @@
+// Drop keys whose value is `undefined` (keeps null/0/'' /false). Used when assembling wire objects so an
+// absent optional field is omitted rather than serialized as `undefined`.
+export const omitUndef = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
+// A parsed wire value as a typed array, or [] when it isn't one — the guard every `build*()` repeats against a
+// JSON payload whose "list" field can arrive missing, null, or (the classic trap) a name-keyed object. The
+// element type is the caller's claim about the rows; pass it explicitly: `asArray<RawFoo>(payload.items)`.
+export const asArray = (value) => (Array.isArray(value) ? value : []);

package/dist/util/text.d.ts

@@ -0,0 +1,2 @@
+export declare const startCase: (value: string) => string;
+export declare const parseDollarAmount: (formatted?: string) => number;

package/dist/util/text.js

@@ -0,0 +1,16 @@
+import { upperFirst, words } from '../libs.js';
+// Title-case a machine value for display, lowercasing each word's tail so SCREAMING_SNAKE and acronyms read as
+// Title Case (`team_tier_1` → 'Team Tier 1', `monthlyCredit` → 'Monthly Credit', `UNCOLLECTIBLE` → 'Uncollectible').
+// Built on lodash word-splitting (camelCase + snake/kebab/space boundaries); empty/whitespace → ''.
+export const startCase = (value) => words(value)
+    .map((w) => upperFirst(w.toLowerCase()))
+    .join(' ');
+// Pull the first signed decimal out of a formatted currency string (`$1,204.55` → 1204.55, `—` → 0). Commas
+// are stripped before matching. Empty/missing/unparseable → 0.
+export const parseDollarAmount = (formatted) => {
+    if (!formatted) {
+        return 0;
+    }
+    const match = formatted.replace(/,/g, '').match(/-?\d+(\.\d+)?/);
+    return match ? parseFloat(match[0]) : 0;
+};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@butinapp/sdk",
+  "version": "0.1.0",
+  "description": "The Butin plugin-authoring contract: descriptor types, the data-view result contract, presets, and edge utilities.",
+  "homepage": "https://butin.app",
+  "bugs": "https://github.com/butinapp/butin/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/butinapp/butin.git",
+    "directory": "packages/sdk"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./data": {
+      "types": "./dist/data/index.d.ts",
+      "import": "./dist/data/index.js"
+    },
+    "./presets": {
+      "types": "./dist/presets/index.d.ts",
+      "import": "./dist/presets/index.js"
+    },
+    "./integrations": {
+      "types": "./dist/integrations/index.d.ts",
+      "import": "./dist/integrations/index.js"
+    },
+    "./util": {
+      "types": "./dist/util/index.d.ts",
+      "import": "./dist/util/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    },
+    "./libs": {
+      "types": "./dist/libs.d.ts",
+      "import": "./dist/libs.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "@types/luxon": "^3.7.1",
+    "lodash-es": "^4.18.1",
+    "luxon": "^3.7.2",
+    "zod": "^4.3.6"
+  },
+  "scripts": {
+    "build": "tsgo -p tsconfig.build.json",
+    "typecheck": "tsgo --noEmit -p tsconfig.json",
+    "test": "vitest run"
+  }
+}