shutro-erp 0.2.0 → 0.3.0

package/dist/contacts/index.js

@@ -27,6 +27,27 @@ export const contacts = defineModule({
         user: { label: 'User', groups: ['contacts.user'] },
         manager: { label: 'Manager', groups: ['contacts.manager'], implies: ['user'] },
     },
+    // A sample customer sheet for the import screen (RFC 0014 §5.4), when Data import is installed.
+    importTemplates: [
+        {
+            key: 'customers',
+            model: 'res.partner',
+            label: 'Customers',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'Company', field: 'isCompany' },
+                { header: 'Email', field: 'email' },
+                { header: 'Phone', field: 'phone' },
+                { header: 'Mobile', field: 'mobile' },
+                { header: 'Street', field: 'street' },
+                { header: 'City', field: 'city' },
+                { header: 'Postal code', field: 'zip' },
+                { header: 'Country', field: 'country' },
+                { header: 'Tax ID', field: 'taxId' },
+                { header: 'Customer', field: 'isCustomer' },
+            ],
+        },
+    ],
     actions: {
         'contacts.action_partners': action(ResPartner, {
             label: 'Contacts',
@@ -57,7 +78,9 @@ export const contacts = defineModule({
                 k.group('identity', ['name', 'isCompany', 'parent', 'taxId']),
                 k.group('reach', ['email', 'phone', 'mobile', 'website']),
                 k.notebook('more', [
-                    k.page('address', 'Address', [k.group('where', ['street', 'city', 'zip', 'country'])]),
+                    k.page('address', 'Address', [
+                        k.group('where', ['street', 'city', 'zip', 'state', 'country']),
+                    ]),
                     k.page('sales', 'Sales & purchase', [
                         k.group('roles', ['isCustomer', 'isVendor', 'currency']),
                     ]),

package/dist/contacts/module.d.ts

@@ -162,6 +162,16 @@ export declare const ResPartner: import("../server/orm.js").Model<"res.partner",
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
+    readonly state: import("../server/orm.js").CharField<{
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string>;
     readonly taxId: import("../server/orm.js").CharField<{
         readonly required: false;
         readonly computed: false;
@@ -335,6 +345,17 @@ export declare const ResPartner: import("../server/orm.js").Model<"res.partner",
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
+    /** State or province (ISO 3166-2: IN-MH, US-CA): the place of supply of taxes split by state. */
+    readonly state: import("../server/orm.js").CharField<{
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string>;
     /** VAT / BIN / tax identification number. */
     readonly taxId: import("../server/orm.js").CharField<{
         readonly required: false;
@@ -552,6 +573,16 @@ export declare const contactsShutro: import("../server/orm.js").Module<readonly
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
+    readonly state: import("../server/orm.js").CharField<{
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string>;
     readonly taxId: import("../server/orm.js").CharField<{
         readonly required: false;
         readonly computed: false;
@@ -725,6 +756,17 @@ export declare const contactsShutro: import("../server/orm.js").Module<readonly
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
+    /** State or province (ISO 3166-2: IN-MH, US-CA): the place of supply of taxes split by state. */
+    readonly state: import("../server/orm.js").CharField<{
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string>;
     /** VAT / BIN / tax identification number. */
     readonly taxId: import("../server/orm.js").CharField<{
         readonly required: false;

package/dist/contacts/module.js

@@ -32,6 +32,8 @@ export const ResPartner = defineModel('res.partner', {
         zip: f.char({ label: 'Postal code' }),
         /** ISO 3166 country code (BD, IN, US, ...). */
         country: f.char({ size: 2 }),
+        /** State or province (ISO 3166-2: IN-MH, US-CA): the place of supply of taxes split by state. */
+        state: f.char({ size: 6, label: 'State / province' }),
         /** VAT / BIN / tax identification number. */
         taxId: f.char({ label: 'Tax ID' }),
         isCustomer: f.boolean({ default: false, label: 'Customer' }),
@@ -49,7 +51,7 @@ export const ResPartner = defineModel('res.partner', {
 });
 export const contactsShutro = defineModule({
     name: 'contacts',
-    version: '0.1.0',
+    version: '0.2.0',
     depends: [baseShutro],
     groups: [
         orm.defineGroup({ code: 'contacts.user', label: 'Contacts user', implies: ['base.user'] }),

package/dist/import/convert.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Cells to field values (RFC 0014 §5.1 step 3): numbers with the file's decimal separator, exact decimals as text
+ * (money is never a JS `number`), dates in the file's day order or ISO, booleans in English and Bangla, selections by
+ * value or label. Bangla digits read as digits. Relations are matched elsewhere (`match.ts`): here they are text.
+ */
+/** A cell as read from a file: CSV cells are text, XLSX cells are typed. */
+export type Cell = string | number | boolean | Date | null;
+export interface ConvertOptions {
+    /** Day order of dates written as text (`03/04/2026`). Default `dmy`. */
+    readonly dateOrder?: 'dmy' | 'mdy' | 'ymd';
+    /** Decimal separator of numbers written as text. Default `.`. */
+    readonly decimal?: '.' | ',';
+    /** Time zone of date-times without an offset. Default `UTC`. */
+    readonly timeZone?: string;
+}
+export interface ConvertField {
+    readonly key: string;
+    readonly kind: string;
+    readonly label: string;
+    readonly options: readonly (readonly [string, string])[] | null;
+}
+/** Why a cell could not be read: a stable code for the UI's messages, and an English text. */
+export interface CellError {
+    readonly code: 'not-a-number' | 'not-an-integer' | 'not-a-date' | 'not-a-datetime' | 'not-a-boolean' | 'not-an-option' | 'not-importable';
+    readonly message: string;
+}
+export type Converted = {
+    readonly value: unknown;
+} | {
+    readonly error: CellError;
+};
+/** Text with Bangla digits as ASCII digits. */
+export declare function asciiDigits(text: string): string;
+/** Whether a field kind can be imported from a cell (relations included; binary and json are not). */
+export declare function importable(kind: string): boolean;
+/** `1,234.50` (or `1.234,50`) → `1234.50`; null when it is not a number. */
+export declare function plainNumber(text: string, decimal: '.' | ','): string | null;
+/** The calendar date of `text` (`2026-04-03`, `03/04/2026` in the day order, `3.4.26`), or null. */
+export declare function parseDate(text: string, order: 'dmy' | 'mdy' | 'ymd'): string | null;
+/** The instant of a wall-clock time in `timeZone`. */
+export declare function zoned(wall: {
+    y: number;
+    mo: number;
+    d: number;
+    h: number;
+    mi: number;
+    s: number;
+}, timeZone: string): Date;
+/** A date and time from text: ISO with an offset as is, else a wall-clock time in `timeZone`. */
+export declare function parseDateTime(text: string, order: 'dmy' | 'mdy' | 'ymd', timeZone: string): Date | null;
+/**
+ * One cell as a value of `field`. Empty cells are `undefined` (left out) — the caller decides between leaving the
+ * field to its default and clearing it.
+ */
+export declare function convertCell(field: ConvertField, cell: Cell, options?: ConvertOptions): Converted | undefined;

package/dist/import/convert.js

@@ -0,0 +1,224 @@
+/**
+ * Cells to field values (RFC 0014 §5.1 step 3): numbers with the file's decimal separator, exact decimals as text
+ * (money is never a JS `number`), dates in the file's day order or ISO, booleans in English and Bangla, selections by
+ * value or label. Bangla digits read as digits. Relations are matched elsewhere (`match.ts`): here they are text.
+ */
+const BANGLA_DIGITS = /[০-৯]/g;
+/** Text with Bangla digits as ASCII digits. */
+export function asciiDigits(text) {
+    return text.replace(BANGLA_DIGITS, (d) => String(d.charCodeAt(0) - 0x09e6));
+}
+const TRUE = new Set(['true', 'yes', 'y', '1', 'x', '✓', 'on', 'হ্যাঁ', 'সত্য', 'হাঁ']);
+const FALSE = new Set(['false', 'no', 'n', '0', 'off', 'না', 'মিথ্যা']);
+/** Whether a field kind can be imported from a cell (relations included; binary and json are not). */
+export function importable(kind) {
+    return kind !== 'binary' && kind !== 'json' && kind !== 'one2many';
+}
+/** `1,234.50` (or `1.234,50`) → `1234.50`; null when it is not a number. */
+export function plainNumber(text, decimal) {
+    let v = asciiDigits(text.trim()).replace(/[\s  '৳$€£¥₹]/g, '');
+    let negative = false;
+    if (/^\(.*\)$/.test(v)) {
+        negative = true; // accounting negatives: (1,200.00)
+        v = v.slice(1, -1);
+    }
+    if (v.startsWith('-')) {
+        negative = !negative;
+        v = v.slice(1);
+    }
+    else if (v.startsWith('+'))
+        v = v.slice(1);
+    const thousands = decimal === '.' ? ',' : '.';
+    if (v.includes(thousands)) {
+        // Groups of three after the first: 1,234,567 — anything else is not a thousands separator.
+        const [whole, ...rest] = v.split(decimal);
+        if (rest.length > 1)
+            return null;
+        const groups = (whole ?? '').split(thousands);
+        if (groups.slice(1).some((g) => g.length !== 3) || (groups[0] ?? '').length === 0)
+            return null;
+        v = [groups.join(''), ...rest].join('.');
+    }
+    else if (decimal === ',')
+        v = v.replace(',', '.');
+    if (!/^(\d+(\.\d*)?|\.\d+)$/.test(v))
+        return null;
+    if (v.startsWith('.'))
+        v = `0${v}`;
+    if (v.endsWith('.'))
+        v = v.slice(0, -1);
+    return negative && !/^0(\.0*)?$/.test(v) ? `-${v}` : v;
+}
+/** A JS number as plain decimal text (no exponent). */
+function numberText(n) {
+    if (Number.isInteger(n))
+        return BigInt(n).toString();
+    const text = String(n);
+    if (!/e/i.test(text))
+        return text;
+    return n.toFixed(20).replace(/0+$/, '').replace(/\.$/, '');
+}
+const pad = (n, width = 2) => String(n).padStart(width, '0');
+const ymd = (y, m, d) => `${pad(y, 4)}-${pad(m)}-${pad(d)}`;
+function validDate(y, m, d) {
+    const date = new Date(Date.UTC(y, m - 1, d));
+    return date.getUTCFullYear() === y && date.getUTCMonth() === m - 1 && date.getUTCDate() === d;
+}
+/** The calendar date of `text` (`2026-04-03`, `03/04/2026` in the day order, `3.4.26`), or null. */
+export function parseDate(text, order) {
+    const v = asciiDigits(text.trim());
+    const iso = /^(\d{4})-(\d{1,2})-(\d{1,2})/.exec(v);
+    let parts = null;
+    if (iso !== null)
+        parts = [Number(iso[1]), Number(iso[2]), Number(iso[3])];
+    else {
+        const m = /^(\d{1,4})[/.\-\s](\d{1,2})[/.\-\s](\d{1,4})$/.exec(v);
+        if (m === null)
+            return null;
+        const [a, b, c] = [Number(m[1]), Number(m[2]), Number(m[3])];
+        if (m[1].length === 4)
+            parts = [a, b, c];
+        else {
+            const year = m[3].length <= 2 ? 2000 + c : c;
+            parts = order === 'mdy' ? [year, a, b] : [year, b, a];
+        }
+    }
+    const [y, mo, d] = parts;
+    return validDate(y, mo, d) ? ymd(y, mo, d) : null;
+}
+/** The offset of `timeZone` from UTC at `utc`, in milliseconds. */
+function offsetOf(timeZone, utc) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        hourCycle: 'h23',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    }).formatToParts(new Date(utc));
+    const get = (type) => Number(parts.find((p) => p.type === type)?.value ?? 0);
+    const local = Date.UTC(get('year'), get('month') - 1, get('day'), get('hour'), get('minute'), get('second'));
+    return local - utc;
+}
+/** The instant of a wall-clock time in `timeZone`. */
+export function zoned(wall, timeZone) {
+    const guess = Date.UTC(wall.y, wall.mo - 1, wall.d, wall.h, wall.mi, wall.s);
+    const first = guess - offsetOf(timeZone, guess);
+    return new Date(guess - offsetOf(timeZone, first));
+}
+/** A date and time from text: ISO with an offset as is, else a wall-clock time in `timeZone`. */
+export function parseDateTime(text, order, timeZone) {
+    const v = asciiDigits(text.trim());
+    if (/^\d{4}-\d{2}-\d{2}T.*(Z|[+-]\d{2}:?\d{2})$/.test(v)) {
+        const date = new Date(v);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    const m = /^(.+?)(?:[T\s]+(\d{1,2}):(\d{2})(?::(\d{2}))?\s*([AaPp][Mm])?)?$/.exec(v);
+    if (m === null)
+        return null;
+    const day = parseDate(m[1], order);
+    if (day === null)
+        return null;
+    let h = Number(m[2] ?? 0);
+    const mi = Number(m[3] ?? 0);
+    const s = Number(m[4] ?? 0);
+    const meridiem = m[5]?.toLowerCase();
+    if (meridiem !== undefined) {
+        if (h < 1 || h > 12)
+            return null;
+        h = (h % 12) + (meridiem === 'pm' ? 12 : 0);
+    }
+    if (h > 23 || mi > 59 || s > 59)
+        return null;
+    const [y, mo, d] = day.split('-').map(Number);
+    return zoned({ y, mo, d, h, mi, s }, timeZone);
+}
+const fail = (code, field, cell, what) => ({
+    error: { code, message: `${field.label}: "${String(cell)}" is not ${what}.` },
+});
+/**
+ * One cell as a value of `field`. Empty cells are `undefined` (left out) — the caller decides between leaving the
+ * field to its default and clearing it.
+ */
+export function convertCell(field, cell, options = {}) {
+    if (cell === null || (typeof cell === 'string' && cell.trim() === ''))
+        return undefined;
+    const order = options.dateOrder ?? 'dmy';
+    const decimal = options.decimal ?? '.';
+    const timeZone = options.timeZone ?? 'UTC';
+    switch (field.kind) {
+        case 'char':
+        case 'text':
+        case 'html':
+        case 'many2one':
+        case 'many2many':
+            if (cell instanceof Date)
+                return { value: cell.toISOString().slice(0, cell.getUTCHours() === 0 ? 10 : 19) };
+            return { value: typeof cell === 'number' ? numberText(cell) : String(cell).trim() };
+        case 'boolean': {
+            if (typeof cell === 'boolean')
+                return { value: cell };
+            if (typeof cell === 'number' && (cell === 0 || cell === 1))
+                return { value: cell === 1 };
+            const v = String(cell).trim().toLowerCase();
+            if (TRUE.has(v))
+                return { value: true };
+            if (FALSE.has(v))
+                return { value: false };
+            return fail('not-a-boolean', field, cell, 'yes or no');
+        }
+        case 'integer':
+        case 'bigint': {
+            const text = typeof cell === 'number' ? numberText(cell) : plainNumber(String(cell), decimal);
+            if (text === null || !/^-?\d+$/.test(text))
+                return fail('not-an-integer', field, cell, 'a whole number');
+            return { value: field.kind === 'bigint' ? text : Number(text) };
+        }
+        case 'float':
+        case 'decimal':
+        case 'monetary':
+        case 'quantity': {
+            if (typeof cell === 'boolean' || cell instanceof Date)
+                return fail('not-a-number', field, cell, 'a number');
+            const text = typeof cell === 'number' ? numberText(cell) : plainNumber(cell, decimal);
+            if (text === null)
+                return fail('not-a-number', field, cell, 'a number');
+            return { value: field.kind === 'float' ? Number(text) : text };
+        }
+        case 'date': {
+            if (cell instanceof Date)
+                return { value: cell.toISOString().slice(0, 10) };
+            const day = typeof cell === 'string' ? parseDate(cell, order) : null;
+            return day === null ? fail('not-a-date', field, cell, 'a date') : { value: day };
+        }
+        case 'datetime': {
+            if (cell instanceof Date) {
+                // Spreadsheet dates have no zone: their wall-clock time is in the file's time zone.
+                const [y, mo, d, h, mi, s] = [
+                    cell.getUTCFullYear(),
+                    cell.getUTCMonth() + 1,
+                    cell.getUTCDate(),
+                    cell.getUTCHours(),
+                    cell.getUTCMinutes(),
+                    cell.getUTCSeconds(),
+                ];
+                return { value: zoned({ y, mo, d, h, mi, s }, timeZone) };
+            }
+            const at = typeof cell === 'string' ? parseDateTime(cell, order, timeZone) : null;
+            return at === null ? fail('not-a-datetime', field, cell, 'a date and time') : { value: at };
+        }
+        case 'selection':
+        case 'state': {
+            const v = (typeof cell === 'number' ? numberText(cell) : String(cell)).trim();
+            const lower = v.toLowerCase();
+            const option = (field.options ?? []).find(([value, label]) => value === v || label.toLowerCase() === lower);
+            return option === undefined
+                ? fail('not-an-option', field, cell, `one of ${(field.options ?? []).map(([, l]) => l).join(', ')}`)
+                : { value: option[0] };
+        }
+        default:
+            return fail('not-importable', field, cell, 'importable');
+    }
+}

package/dist/import/csv.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A CSV reader without dependencies (RFC 0014 §5.1): the encoding is read from the byte-order mark, else UTF-8 when
+ * the bytes are valid UTF-8, else Windows-1252 (spreadsheets saved by older Excel); the separator is guessed from the
+ * first lines (`,` `;` tab `|`); quoted cells may hold separators, quotes (`""`) and newlines (RFC 4180).
+ */
+export type CsvEncoding = 'utf-8' | 'utf-16le' | 'utf-16be' | 'windows-1252';
+export interface CsvOptions {
+    /** Default: guessed. */
+    readonly separator?: string;
+    /** Default: from the byte-order mark or the bytes. */
+    readonly encoding?: CsvEncoding;
+}
+export interface CsvTable {
+    readonly rows: string[][];
+    readonly separator: string;
+    readonly encoding: CsvEncoding;
+}
+/** The text of `bytes` and the encoding it was read in. */
+export declare function decodeText(bytes: Uint8Array, given?: CsvEncoding): {
+    text: string;
+    encoding: CsvEncoding;
+};
+/** The separator found the same number of times on the most of the first lines (ties: the earlier in the list). */
+export declare function guessSeparator(text: string): string;
+/** Splits `text` into rows of cells. Trailing empty rows are dropped. */
+export declare function parseCsvText(text: string, separator: string): string[][];
+/** Reads a CSV file. */
+export declare function readCsv(bytes: Uint8Array, options?: CsvOptions): CsvTable;

package/dist/import/csv.js

@@ -0,0 +1,115 @@
+/**
+ * A CSV reader without dependencies (RFC 0014 §5.1): the encoding is read from the byte-order mark, else UTF-8 when
+ * the bytes are valid UTF-8, else Windows-1252 (spreadsheets saved by older Excel); the separator is guessed from the
+ * first lines (`,` `;` tab `|`); quoted cells may hold separators, quotes (`""`) and newlines (RFC 4180).
+ */
+const SEPARATORS = [',', ';', '\t', '|'];
+/** The text of `bytes` and the encoding it was read in. */
+export function decodeText(bytes, given) {
+    const [a, b, c] = bytes;
+    let encoding = given;
+    if (encoding === undefined) {
+        if (a === 0xef && b === 0xbb && c === 0xbf)
+            encoding = 'utf-8';
+        else if (a === 0xff && b === 0xfe)
+            encoding = 'utf-16le';
+        else if (a === 0xfe && b === 0xff)
+            encoding = 'utf-16be';
+    }
+    if (encoding !== undefined)
+        // TextDecoder drops the byte-order mark of its own encoding.
+        return { text: new TextDecoder(encoding).decode(bytes), encoding };
+    try {
+        return { text: new TextDecoder('utf-8', { fatal: true }).decode(bytes), encoding: 'utf-8' };
+    }
+    catch {
+        return { text: new TextDecoder('windows-1252').decode(bytes), encoding: 'windows-1252' };
+    }
+}
+/** Counts of `separator` outside quotes in each of the first lines. */
+function counts(text, separator, lines) {
+    const out = [];
+    let quoted = false;
+    let n = 0;
+    for (let i = 0; i < text.length && out.length < lines; i++) {
+        const ch = text[i];
+        if (ch === '"')
+            quoted = !quoted;
+        else if (!quoted && ch === separator)
+            n += 1;
+        else if (!quoted && ch === '\n') {
+            out.push(n);
+            n = 0;
+        }
+    }
+    if (out.length < lines && n > 0)
+        out.push(n);
+    return out;
+}
+/** The separator found the same number of times on the most of the first lines (ties: the earlier in the list). */
+export function guessSeparator(text) {
+    let best = ',';
+    let bestScore = 0;
+    for (const separator of SEPARATORS) {
+        const seen = counts(text, separator, 10).filter((n) => n > 0);
+        const first = seen[0];
+        if (first === undefined)
+            continue;
+        const score = seen.filter((n) => n === first).length * 1000 + first;
+        if (score > bestScore) {
+            best = separator;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+/** Splits `text` into rows of cells. Trailing empty rows are dropped. */
+export function parseCsvText(text, separator) {
+    const rows = [];
+    let row = [];
+    let cell = '';
+    let quoted = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (quoted) {
+            if (ch !== '"')
+                cell += ch;
+            else if (text[i + 1] === '"') {
+                cell += '"';
+                i += 1;
+            }
+            else
+                quoted = false;
+        }
+        else if (ch === '"' && cell === '')
+            quoted = true;
+        else if (ch === separator) {
+            row.push(cell);
+            cell = '';
+        }
+        else if (ch === '\n' || ch === '\r') {
+            if (ch === '\r' && text[i + 1] === '\n')
+                i += 1;
+            row.push(cell);
+            rows.push(row);
+            row = [];
+            cell = '';
+        }
+        else
+            cell += ch;
+    }
+    if (cell !== '' || row.length > 0) {
+        row.push(cell);
+        rows.push(row);
+    }
+    while (rows.length > 0 && rows.at(-1).every((c) => c === ''))
+        rows.pop();
+    return rows;
+}
+/** Reads a CSV file. */
+export function readCsv(bytes, options = {}) {
+    const { text, encoding } = decodeText(bytes, options.encoding);
+    const body = text.startsWith('') ? text.slice(1) : text;
+    const separator = options.separator ?? guessSeparator(body);
+    return { rows: parseCsvText(body, separator), separator, encoding };
+}

package/dist/import/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @packageDocumentation
+ * `shutro-erp/import` (RFC 0014): CSV and XLSX files become records of any served model — columns mapped to fields
+ * (guessed from keys and labels), cells converted (decimals exact, dates in the file's order, Bangla digits),
+ * relations matched by external id, unique key or name as the user, a dry run with every error on its row and cell,
+ * and an all-or-nothing import that is audited. Nothing is bypassed: record rules, field security, constraints and
+ * sequences apply as for a record typed in a form.
+ */
+import { type KoshModule } from '../modules-sdk/index.js';
+import { type ImportRoutesOptions } from './routes.js';
+export { asciiDigits, type Cell, type CellError, type Converted, type ConvertField, type ConvertOptions, convertCell, importable, parseDate, parseDateTime, plainNumber, } from './convert.js';
+export { type CsvEncoding, type CsvTable, decodeText, guessSeparator, parseCsvText, readCsv, } from './csv.js';
+export { type ColumnMapping, guessMapping, type MappableField, normalize } from './mapping.js';
+export { type Match, type MatchTarget, matchAll, matchOne } from './match.js';
+export { importShutro } from './models.js';
+export { type ImportRoutesOptions, registerImportRoutes } from './routes.js';
+export { EXTERNAL_ID_KEY, externalIdOf, ID_KEY, IMPORT_MODULE, type ImportField, type ImportModels, type ImportOptions, type ImportResult, importFields, type RowError, type RowErrorCode, runImport, type UndoData, type UndoResult, undoImport, WRITE_BATCH, } from './run.js';
+export { createImportService, FINISHED_TOPIC, IMPORT_MAX_BYTES, IMPORT_ROWS, type ImportContext, type ImportService, INLINE_ROWS, parseOptions, RUN_JOB, type SavedMapping, type Session, UNDO_DAYS, } from './service.js';
+export { importWorker } from './worker.js';
+export { fromSerial, isDateFormat, readXlsx, unzip, type XlsxCell, XlsxError, type XlsxSheet, xlsxSheetNames, } from './xlsx.js';
+/** Package identity. */
+export declare const PACKAGE: {
+    readonly name: string;
+    readonly rfc: string;
+};
+export interface ImportModuleOptions extends Omit<ImportRoutesOptions, 'service'> {
+    /** Run background imports in this process (default: unless `KOSH_SCHEDULES=off`). */
+    readonly worker?: boolean;
+}
+/** The import module with explicit limits (tests). */
+export declare function createImport(options?: ImportModuleOptions): KoshModule;
+/** Data import, limits from the environment (`KOSH_IMPORT_MAX_BYTES`, `KOSH_IMPORT_MAX_ROWS`). */
+export declare const dataImport: KoshModule;

package/dist/import/index.js

@@ -0,0 +1,60 @@
+/**
+ * @packageDocumentation
+ * `shutro-erp/import` (RFC 0014): CSV and XLSX files become records of any served model — columns mapped to fields
+ * (guessed from keys and labels), cells converted (decimals exact, dates in the file's order, Bangla digits),
+ * relations matched by external id, unique key or name as the user, a dry run with every error on its row and cell,
+ * and an all-or-nothing import that is audited. Nothing is bypassed: record rules, field security, constraints and
+ * sequences apply as for a record typed in a form.
+ */
+import { defineModule } from '../modules-sdk/index.js';
+import { base } from '../server/index.js';
+import { importShutro } from './models.js';
+import { registerImportRoutes } from './routes.js';
+import { createImportService } from './service.js';
+import { importWorker } from './worker.js';
+export { asciiDigits, convertCell, importable, parseDate, parseDateTime, plainNumber, } from './convert.js';
+export { decodeText, guessSeparator, parseCsvText, readCsv, } from './csv.js';
+export { guessMapping, normalize } from './mapping.js';
+export { matchAll, matchOne } from './match.js';
+export { importShutro } from './models.js';
+export { registerImportRoutes } from './routes.js';
+export { EXTERNAL_ID_KEY, externalIdOf, ID_KEY, IMPORT_MODULE, importFields, runImport, undoImport, WRITE_BATCH, } from './run.js';
+export { createImportService, FINISHED_TOPIC, IMPORT_MAX_BYTES, IMPORT_ROWS, INLINE_ROWS, parseOptions, RUN_JOB, UNDO_DAYS, } from './service.js';
+export { importWorker } from './worker.js';
+export { fromSerial, isDateFormat, readXlsx, unzip, XlsxError, xlsxSheetNames, } from './xlsx.js';
+/** Package identity. */
+export const PACKAGE = Object.freeze({
+    name: 'shutro-erp/import',
+    rfc: 'RFC 0014',
+});
+/** The import module with explicit limits (tests). */
+export function createImport(options = {}) {
+    const env = process.env;
+    const maxBytes = Number(env['KOSH_IMPORT_MAX_BYTES'] ?? Number.NaN);
+    const maxRows = Number(env['KOSH_IMPORT_MAX_ROWS'] ?? Number.NaN);
+    return defineModule({
+        shutro: importShutro,
+        kosh: '^0.1.0',
+        depends: [base],
+        accessLevels: { user: { label: 'Import data', groups: ['import.user'] } },
+        privateModels: ['import.session', 'import.progress', 'import.mapping'],
+        routes: (context) => {
+            const { worker, ...limits } = options;
+            const service = createImportService(context, limits.inlineRows === undefined ? {} : { inlineRows: limits.inlineRows });
+            registerImportRoutes(context, {
+                ...(Number.isFinite(maxBytes) && maxBytes > 0 ? { maxBytes } : {}),
+                ...(Number.isFinite(maxRows) && maxRows > 0 ? { maxRows } : {}),
+                ...limits,
+                service,
+            });
+            // Background work is off in the CLI (kosh init, migrate), like the schedules.
+            if (!(worker ?? env['KOSH_SCHEDULES'] !== 'off'))
+                return;
+            const running = importWorker(context, service);
+            running.start();
+            context.app.addHook('onClose', () => running.stop());
+        },
+    });
+}
+/** Data import, limits from the environment (`KOSH_IMPORT_MAX_BYTES`, `KOSH_IMPORT_MAX_ROWS`). */
+export const dataImport = createImport();

package/dist/import/mapping.d.ts

@@ -0,0 +1,15 @@
+export interface MappableField {
+    readonly key: string;
+    readonly kind: string;
+    readonly label: string;
+}
+/** A column of the file and the field it fills, or null to skip it. */
+export interface ColumnMapping {
+    readonly index: number;
+    readonly header: string;
+    readonly field: string | null;
+}
+/** Lower case, letters and digits only (Bangla letters kept). */
+export declare function normalize(text: string): string;
+/** The field each header most likely fills: an exact key, then an exact label; each field once. */
+export declare function guessMapping(headers: readonly string[], fields: readonly MappableField[]): ColumnMapping[];