@naturalcycles/nodejs-lib 15.139.0 → 15.141.0

package/dist/exec2/exec2.js

@@ -1,4 +1,5 @@
 import { execSync, spawn, spawnSync } from 'node:child_process';
+import { nowUnixMillis } from '@naturalcycles/js-lib/datetime/localTime.js';
 import { _since } from '@naturalcycles/js-lib/datetime/time.util.js';
 import { AppError } from '@naturalcycles/js-lib/error/error.util.js';
 import { _substringAfterLast } from '@naturalcycles/js-lib/string/string.util.js';
@@ -53,7 +54,7 @@ class Exec2 {
         const log = opt.log ?? true; // by default log should be true, as we are printing the output
         // Copy, to not mutate the input options
         opt = { ...opt, log, logStart: opt.logStart ?? log, logFinish: opt.logFinish ?? log };
-        const started = Date.now();
+        const started = nowUnixMillis();
         this.logStart(cmd, opt);
         const r = spawnSync(cmd, opt.args, {
             encoding: 'utf8',
@@ -98,7 +99,7 @@ class Exec2 {
             logStart: opt.logStart ?? opt.log ?? false,
             logFinish: opt.logFinish ?? opt.log ?? false,
         };
-        const started = Date.now();
+        const started = nowUnixMillis();
         this.logStart(cmd, opt);
         try {
             const s = execSync(cmd, {
@@ -148,7 +149,7 @@ class Exec2 {
         const log = opt.log ?? true; // by default log should be true, as we are printing the output
         // Copy, to not mutate the input options
         opt = { ...opt, log, logStart: opt.logStart ?? log, logFinish: opt.logFinish ?? log };
-        const started = Date.now();
+        const started = nowUnixMillis();
         this.logStart(cmd, opt);
         await new Promise((resolve, reject) => {
             const p = spawn(cmd, opt.args || [], {
@@ -203,7 +204,7 @@ class Exec2 {
         const log = opt.log ?? printWhileRunning; // by default log should be true, as we are printing the output
         // Copy, to not mutate the input options
         opt = { ...opt, log, logStart: opt.logStart ?? log, logFinish: opt.logFinish ?? log };
-        const started = Date.now();
+        const started = nowUnixMillis();
         this.logStart(cmd, opt);
         let stdout = '';
         let stderr = '';

package/dist/fs/kpy.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
-import { _since, localTime } from '@naturalcycles/js-lib/datetime';
+import { _since, nowUnixMillis } from '@naturalcycles/js-lib/datetime';
 import { glob, globSync } from 'tinyglobby';
 import { boldWhite, dimGrey, grey, yellow } from '../colors/colors.js';
 import { fs2 } from './fs2.js';
 export async function kpy(opt) {
-    const started = localTime.nowUnixMillis();
+    const started = nowUnixMillis();
     opt = kpyPrepare(opt);
     const filenames = await glob(opt.inputPatterns, {
         cwd: opt.baseDir,
@@ -33,7 +33,7 @@ export async function kpy(opt) {
     kpyLogResult(opt, filenames, started);
 }
 export function kpySync(opt) {
-    const started = localTime.nowUnixMillis();
+    const started = nowUnixMillis();
     opt = kpyPrepare(opt);
     const filenames = globSync(opt.inputPatterns, {
         cwd: opt.baseDir,

package/dist/jwt/jwt.service.js

@@ -78,6 +78,7 @@ export class JWTService {
             const { payload } = await jwtVerify(token, key, {
                 algorithms: this.cfg.verifyAlgorithms || [this.cfg.algorithm],
                 ...joseOpt,
+                // oxlint-disable-next-line no-restricted-globals -- jose expects a Date
                 currentDate: now === undefined ? undefined : new Date(now * 1000),
             });
             data = payload;

package/dist/stream/progressLogger.js

@@ -35,8 +35,8 @@ export class ProgressLogger {
     progress;
     peakRSS;
     start() {
-        this.started = Date.now();
-        this.lastSecondStarted = Date.now();
+        this.started = localTime.nowUnixMillis();
+        this.lastSecondStarted = localTime.nowUnixMillis();
         this.sma = new SimpleMovingAverage(10);
         this.processedLastSecond = 0;
         this.progress = 0;
@@ -60,7 +60,7 @@ export class ProgressLogger {
             return;
         const { metric, extra, chunkSize, heapUsed: logHeapUsed, heapTotal: logHeapTotal, rss: logRss, peakRSS: logPeakRss, rssMinusHeap, external, arrayBuffers, logRPS, logger, } = this.cfg;
         const mem = process.memoryUsage();
-        const now = Date.now();
+        const now = localTime.nowUnixMillis();
         const batchedProgress = this.progress * chunkSize;
         const lastRPS = (this.processedLastSecond * chunkSize) / ((now - this.lastSecondStarted) / 1000) || 0;
         const rpsTotal = Math.round(batchedProgress / ((now - this.started) / 1000)) || 0;

package/dist/stream/transform/transformMap.js

@@ -1,6 +1,6 @@
 import { Transform } from 'node:stream';
 import { _hc } from '@naturalcycles/js-lib';
-import { _since } from '@naturalcycles/js-lib/datetime';
+import { _since, nowUnixMillis } from '@naturalcycles/js-lib/datetime';
 import { _anyToError, _assert, ErrorMode } from '@naturalcycles/js-lib/error';
 import { createCommonLoggerAtLevel } from '@naturalcycles/js-lib/log';
 import { pDefer } from '@naturalcycles/js-lib/promise/pDefer.js';
@@ -43,7 +43,7 @@ export function transformMap(mapper, opt = {}) {
         async transform(chunk, _, cb) {
             // Initialize start time on first item
             if (started === 0) {
-                started = Date.now();
+                started = nowUnixMillis();
                 lastWarmupCheck = started;
             }
             if (isSettled)
@@ -150,7 +150,7 @@ export function transformMap(mapper, opt = {}) {
         },
     });
     function updateConcurrency() {
-        const now = Date.now();
+        const now = nowUnixMillis();
         if (now - lastWarmupCheck < WARMUP_CHECK_INTERVAL_MS)
             return;
         lastWarmupCheck = now;

package/dist/stream/transform/transformMapSync.js

@@ -1,4 +1,5 @@
 import { Transform } from 'node:stream';
+import { nowUnixMillis } from '@naturalcycles/js-lib/datetime/localTime.js';
 import { _anyToError, _assert, ErrorMode } from '@naturalcycles/js-lib/error';
 import { createCommonLoggerAtLevel } from '@naturalcycles/js-lib/log';
 import { END, SKIP } from '@naturalcycles/js-lib/types';
@@ -11,7 +12,7 @@ import { PIPELINE_GRACEFUL_ABORT } from '../stream.util.js';
 export function transformMapSync(mapper, opt = {}) {
     const { predicate, // defaults to "no predicate" (pass everything)
     errorMode = ErrorMode.THROW_IMMEDIATELY, onError, onDone, metric = 'stream', objectMode = true, signal, } = opt;
-    const started = Date.now();
+    const started = nowUnixMillis();
     let index = -1;
     let countOut = 0;
     let isSettled = false;

package/dist/stream/transform/transformThrottle.js

@@ -48,7 +48,7 @@ export function transformThrottle(opt) {
             if (++count >= throughput) {
                 // console.log('pausing now after', {item, count})
                 lock = pDefer();
-                logger.log(`${localTime.now().toPretty()} transformThrottle activated: ${count} items passed in ${_since(start)}, will pause for ${_ms(interval * 1000 - (Date.now() - start))}`);
+                logger.log(`${localTime.now().toPretty()} transformThrottle activated: ${count} items passed in ${_since(start)}, will pause for ${_ms(interval * 1000 - (localTime.nowUnixMillis() - start))}`);
             }
             cb(null, item); // pass the item through
         },

package/dist/stream/transform/transformThrottleByRSS.js

@@ -39,7 +39,7 @@ export function transformThrottleByRSS(opt) {
             }
             if (!disabled && lastRSS > maxRSSBytes && !lock) {
                 lock = pDefer();
-                pausedSince = Date.now();
+                pausedSince = localTime.nowUnixMillis();
                 logger.log(`${localTime.now().toPretty()} transformThrottleByRSS paused: RSS ${_mb(lastRSS)} > ${maxRSS} MB`);
                 pollTimer = setTimeout(() => pollRSS(), pollInterval);
             }
@@ -67,7 +67,7 @@ export function transformThrottleByRSS(opt) {
             lock.resolve();
             lock = undefined;
         }
-        else if (pollTimeout && Date.now() - pausedSince >= pollTimeout) {
+        else if (pollTimeout && localTime.nowUnixMillis() - pausedSince >= pollTimeout) {
             clearTimeout(rssCheckTimer);
             if (onPollTimeout === 'throw') {
                 lock.reject(new Error(`transformThrottleByRSS pollTimeout of ${_ms(pollTimeout)} reached, RSS ${_mb(rss)} still > ${maxRSS} MB`));

package/dist/validation/ajv/getAjv.js

@@ -2,7 +2,7 @@ import { _isBetween, _lazyValue, _round } from '@naturalcycles/js-lib';
 import { _assert } from '@naturalcycles/js-lib/error';
 import { _deepCopy, _mapObject, Set2 } from '@naturalcycles/js-lib/object';
 import { _substringAfterLast } from '@naturalcycles/js-lib/string';
-import { Ajv2020 } from 'ajv/dist/2020.js';
+import { _, Ajv2020, str } from 'ajv/dist/2020.js';
 import { validTLDs } from '../tlds.js';
 import { jFormats } from './jsonSchemaBuilder.util.js';
 // oxlint-disable unicorn/prefer-code-point
@@ -265,130 +265,70 @@ export function createAjv(opt) {
             return true;
         },
     });
+    // The date/time keywords are `code` keywords, which Ajv inlines into the compiled validator.
+    // A `validate` keyword is a function call with a context object, whose instancePath Ajv builds
+    // on every call (escaping the key of every map entry), even for valid data.
     ajv.addKeyword({
         keyword: 'IsoDate',
         type: 'string',
-        modifying: false,
-        errors: true,
         schemaType: 'object',
-        validate: function validate(opt, data, _schema, ctx) {
-            const hasOptions = Object.keys(opt).length > 0;
-            const isValid = isIsoDateValid(data);
-            if (!isValid) {
-                ;
-                validate.errors = [
-                    {
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is an invalid IsoDate`,
-                    },
-                ];
-                return false;
-            }
-            if (!hasOptions)
-                return true;
-            const { before, sameOrBefore, after, sameOrAfter } = opt;
-            const errors = [];
-            if (before) {
-                const isParamValid = isIsoDateValid(before);
-                const isRuleValid = isParamValid && before > data;
-                if (!isRuleValid) {
-                    errors.push({
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is not before ${before}`,
-                    });
-                }
-            }
-            if (sameOrBefore) {
-                const isParamValid = isIsoDateValid(sameOrBefore);
-                const isRuleValid = isParamValid && sameOrBefore >= data;
-                if (!isRuleValid) {
-                    errors.push({
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is not the same or before ${sameOrBefore}`,
-                    });
-                }
-            }
-            if (after) {
-                const isParamValid = isIsoDateValid(after);
-                const isRuleValid = isParamValid && after < data;
-                if (!isRuleValid) {
-                    errors.push({
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is not after ${after}`,
-                    });
-                }
-            }
-            if (sameOrAfter) {
-                const isParamValid = isIsoDateValid(sameOrAfter);
-                const isRuleValid = isParamValid && sameOrAfter <= data;
-                if (!isRuleValid) {
-                    errors.push({
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is not the same or after ${sameOrAfter}`,
-                    });
+        error: {
+            message: ({ params }) => params['rule']
+                ? str `is not ${isoDateRuleLabels[params['rule']]} ${params['limit']}`
+                : str `is an invalid IsoDate`,
+            params: ({ params }) => (params['rule'] ? _ `{${params['rule']}: ${params['limit']}}` : _ `{}`),
+        },
+        code(cxt) {
+            const { gen, data } = cxt;
+            const opt = cxt.schema;
+            const isValid = gen.scopeValue('func', { ref: isIsoDateValid });
+            gen.if(_ `!${isValid}(${data})`, () => cxt.error(), () => {
+                for (const rule of isoDateRules) {
+                    const limit = opt[rule];
+                    if (!limit)
+                        continue;
+                    const params = { rule, limit };
+                    if (!isIsoDateValid(limit)) {
+                        // An invalid limit rejects every date
+                        cxt.error(false, params);
+                        continue;
+                    }
+                    gen.if(isoDateRuleFails(rule, data, limit), () => cxt.error(false, params));
                 }
-            }
-            if (errors.length === 0)
-                return true;
-            validate.errors = errors;
-            return false;
+            });
         },
     });
     ajv.addKeyword({
         keyword: 'IsoDateTime',
         type: 'string',
-        modifying: false,
-        errors: true,
         schemaType: 'boolean',
-        validate: function validate(_opt, data, _schema, ctx) {
-            const isValid = isIsoDateTimeValid(data);
-            if (isValid)
-                return true;
-            validate.errors = [
-                {
-                    instancePath: ctx?.instancePath ?? '',
-                    message: `is an invalid IsoDateTime`,
-                },
-            ];
-            return false;
+        error: { message: 'is an invalid IsoDateTime' },
+        code(cxt) {
+            const isValid = cxt.gen.scopeValue('func', { ref: isIsoDateTimeValid });
+            cxt.fail(_ `!${isValid}(${cxt.data})`);
         },
     });
     ajv.addKeyword({
         keyword: 'IsoMonth',
         type: 'string',
-        modifying: false,
-        errors: true,
         schemaType: 'object',
-        validate: function validate(_opt, data, _schema, ctx) {
-            const isValid = isIsoMonthValid(data);
-            if (isValid)
-                return true;
-            validate.errors = [
-                {
-                    instancePath: ctx?.instancePath ?? '',
-                    message: `is an invalid IsoMonth`,
-                },
-            ];
-            return false;
+        error: { message: 'is an invalid IsoMonth' },
+        code(cxt) {
+            const isValid = cxt.gen.scopeValue('func', { ref: isIsoMonthValid });
+            cxt.fail(_ `!${isValid}(${cxt.data})`);
         },
     });
     ajv.addKeyword({
         keyword: 'UtcOffset',
         type: 'string',
-        modifying: false,
-        errors: true,
         schemaType: 'object',
-        validate: function validate(opt, data, _schema, ctx) {
-            const isValid = data === 'Z' ? opt.allowZ : data !== '' && isIsoTimezoneValid(data);
-            if (isValid)
-                return true;
-            validate.errors = [
-                {
-                    instancePath: ctx?.instancePath ?? '',
-                    message: `is an invalid UtcOffset`,
-                },
-            ];
-            return false;
+        error: { message: 'is an invalid UtcOffset' },
+        code(cxt) {
+            const opt = cxt.schema;
+            const isValid = cxt.gen.scopeValue('func', {
+                ref: opt.allowZ ? isUtcOffsetOrZValid : isUtcOffsetValid,
+            });
+            cxt.fail(_ `!${isValid}(${cxt.data})`);
         },
     });
     // Annotation only (the values are validated by `enum`), registered so strict mode doesn't reject it
@@ -425,35 +365,62 @@ export function createAjv(opt) {
             return true;
         },
     });
+    // Strips the keys that don't match the key schema; the values are validated by `additionalProperties`.
+    // The key schema is inlined per key with error reporting off, and the error count is reset after
+    // a mismatch, so a stripped key never surfaces as an error. Keys listed in `properties` are skipped.
     ajv.addKeyword({
         keyword: 'keySchema',
         type: 'object',
-        modifying: true,
-        errors: false,
         schemaType: 'object',
-        compile(innerSchema, _parentSchema, _it) {
-            const isValidKeyFn = ajv.compile(innerSchema);
-            function validate(data, _ctx) {
-                if (typeof data !== 'object' || data === null)
-                    return true;
-                for (const key of Object.keys(data)) {
-                    if (!isValidKeyFn(key)) {
-                        delete data[key];
-                    }
+        trackErrors: true,
+        code(cxt) {
+            const { gen, data, parentSchema } = cxt;
+            const propertyNames = Object.keys(parentSchema['properties'] || {});
+            const valid = gen.name('valid');
+            gen.forIn('key', data, key => {
+                const checkKey = () => {
+                    cxt.subschema({
+                        keyword: 'keySchema',
+                        data: key,
+                        dataTypes: ['string'],
+                        compositeRule: true,
+                        createErrors: false,
+                        allErrors: false,
+                    }, valid);
+                    gen.if(_ `!${valid}`, () => {
+                        cxt.reset();
+                        gen.code(_ `delete ${data}[${key}]`);
+                    });
+                };
+                if (!propertyNames.length)
+                    return checkKey();
+                let isNotProperty = _ `${key} !== ${propertyNames[0]}`;
+                for (const name of propertyNames.slice(1)) {
+                    isNotProperty = _ `${isNotProperty} && ${key} !== ${name}`;
                 }
-                return true;
-            }
-            return validate;
+                gen.if(isNotProperty, checkKey);
+            });
         },
     });
-    // Validates that the value is undefined. Used in record/stringMap with optional value schemas
-    // to allow undefined values in patternProperties via anyOf.
+    // Validates the inner schema only when the value is defined. Used for the optional values of
+    // `stringMap`/`record`, whose `additionalProperties` loop visits the keys with undefined values too.
+    ajv.addKeyword({
+        keyword: 'ifDefined',
+        schemaType: ['object', 'boolean'],
+        code(cxt) {
+            const { gen, data } = cxt;
+            gen.if(_ `${data} !== undefined`, () => {
+                cxt.subschema({ keyword: 'ifDefined' }, gen.name('valid'));
+            });
+        },
+    });
+    // Validates that the value is undefined. Superseded by `ifDefined`, kept for raw JSON schemas.
     ajv.addKeyword({
         keyword: 'isUndefined',
-        modifying: false,
-        errors: false,
         schemaType: 'boolean',
-        validate: (_schema, data) => data === undefined,
+        code(cxt) {
+            cxt.fail(_ `${cxt.data} !== undefined`);
+        },
     });
     // This is added because Ajv validates the `min/maxProperties` before validating the properties.
     // So, in case of `minProperties(1)` and `{ foo: 'bar' }` Ajv will let it pass, even
@@ -660,6 +627,25 @@ export function createAjv(opt) {
     });
     return ajv;
 }
+const isoDateRules = ['before', 'sameOrBefore', 'after', 'sameOrAfter'];
+const isoDateRuleLabels = {
+    before: 'before',
+    sameOrBefore: 'the same or before',
+    after: 'after',
+    sameOrAfter: 'the same or after',
+};
+/**
+ * IsoDate strings compare chronologically as plain strings.
+ */
+function isoDateRuleFails(rule, data, limit) {
+    if (rule === 'before')
+        return _ `${data} >= ${limit}`;
+    if (rule === 'sameOrBefore')
+        return _ `${data} > ${limit}`;
+    if (rule === 'after')
+        return _ `${data} <= ${limit}`;
+    return _ `${data} < ${limit}`;
+}
 const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 const DASH_CODE = '-'.charCodeAt(0);
 const ZERO_CODE = '0'.charCodeAt(0);
@@ -788,6 +774,12 @@ function isIsoTimezoneValid(s) {
         return false; // min is -12:00
     return true;
 }
+function isUtcOffsetValid(s) {
+    return s !== 'Z' && s !== '' && isIsoTimezoneValid(s);
+}
+function isUtcOffsetOrZValid(s) {
+    return s === 'Z' || (s !== '' && isIsoTimezoneValid(s));
+}
 /**
  * This is a performance optimized correct validation
  * for ISO month formatted as "YYYY-MM".

package/dist/validation/ajv/jSchema.d.ts

@@ -307,6 +307,7 @@ export declare class JIsoDate<Opt extends boolean = false> extends JBuilder<IsoD
     after(date: string): this;
     sameOrAfter(date: string): this;
     between(fromDate: string, toDate: string, incl: Inclusiveness): this;
+    private addRules;
 }
 export interface JsonSchemaIsoDateOptions {
     before?: string;
@@ -387,6 +388,10 @@ export declare class JObject<OUT extends AnyObject, Opt extends boolean = false>
 }
 interface JObjectOpts {
     hasIsOfTypeCheck?: false;
+    /**
+     * Schema for every property not listed in `properties`, e.g the values of a string map.
+     */
+    additionalProperties?: JsonSchema<any>;
     patternProperties?: StringMap<JsonSchema<any>>;
     keySchema?: JsonSchema;
 }
@@ -574,7 +579,7 @@ export interface JsonSchema<OUT = unknown> {
     };
     patternProperties?: StringMap<JsonSchema<any>>;
     required?: string[];
-    additionalProperties?: boolean;
+    additionalProperties?: boolean | JsonSchema<any>;
     minProperties?: number;
     maxProperties?: number;
     default?: OUT;
@@ -626,6 +631,10 @@ export interface JsonSchema<OUT = unknown> {
     errorMessages?: StringMap<string>;
     optionalValues?: (string | number | boolean | null)[];
     keySchema?: JsonSchema;
+    /**
+     * Validates the value against the given schema only when it's defined.
+     */
+    ifDefined?: JsonSchema;
     isUndefined?: true;
     minProperties2?: number;
     exclusiveProperties?: (readonly string[])[];

package/dist/validation/ajv/jSchema.js

@@ -38,13 +38,13 @@ export const j = {
             const isValueOptional = schema.getSchema().optionalField;
             const builtSchema = schema.build();
             const finalValueSchema = isValueOptional
-                ? { anyOf: [{ isUndefined: true }, builtSchema] }
+                ? { ifDefined: builtSchema }
                 : builtSchema;
+            // `additionalProperties` instead of `patternProperties: { '^.+$': ... }`, which made Ajv
+            // regex-test every key twice (once more for `additionalProperties: false`)
             return new JObject({}, {
                 hasIsOfTypeCheck: false,
-                patternProperties: {
-                    '^.+$': finalValueSchema,
-                },
+                additionalProperties: finalValueSchema,
             });
         },
         /**
@@ -695,26 +695,25 @@ export class JIsoDate extends JBuilder {
         });
     }
     before(date) {
-        return this.cloneAndUpdateSchema({ IsoDate: { before: date } });
+        return this.addRules({ before: date });
     }
     sameOrBefore(date) {
-        return this.cloneAndUpdateSchema({ IsoDate: { sameOrBefore: date } });
+        return this.addRules({ sameOrBefore: date });
     }
     after(date) {
-        return this.cloneAndUpdateSchema({ IsoDate: { after: date } });
+        return this.addRules({ after: date });
     }
     sameOrAfter(date) {
-        return this.cloneAndUpdateSchema({ IsoDate: { sameOrAfter: date } });
+        return this.addRules({ sameOrAfter: date });
     }
     between(fromDate, toDate, incl) {
-        let schemaPatch = {};
         if (incl === '[)') {
-            schemaPatch = { IsoDate: { sameOrAfter: fromDate, before: toDate } };
-        }
-        else if (incl === '[]') {
-            schemaPatch = { IsoDate: { sameOrAfter: fromDate, sameOrBefore: toDate } };
+            return this.addRules({ sameOrAfter: fromDate, before: toDate });
         }
-        return this.cloneAndUpdateSchema(schemaPatch);
+        return this.addRules({ sameOrAfter: fromDate, sameOrBefore: toDate });
+    }
+    addRules(rules) {
+        return this.cloneAndUpdateSchema({ IsoDate: { ...this.schema.IsoDate, ...rules } });
     }
 }
 export class JNumber extends JBuilder {
@@ -832,7 +831,7 @@ export class JObject extends JBuilder {
             type: 'object',
             properties: {},
             required: [],
-            additionalProperties: false,
+            additionalProperties: opt?.additionalProperties ?? false,
             hasIsOfTypeCheck: opt?.hasIsOfTypeCheck ?? true,
             patternProperties: opt?.patternProperties ?? undefined,
             keySchema: opt?.keySchema ?? undefined,
@@ -844,6 +843,9 @@ export class JObject extends JBuilder {
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties() {
+        // A string map already accepts every property, validated by its value schema
+        if (typeof this.schema.additionalProperties === 'object')
+            return this.clone();
         return this.cloneAndUpdateSchema({ additionalProperties: true });
     }
     extend(props) {
@@ -1024,16 +1026,13 @@ function record(keySchema, valueSchema) {
     // Check if value schema is optional before build() strips the optionalField flag
     const isValueOptional = valueSchema.getSchema().optionalField;
     const valueJsonSchema = valueSchema.build();
-    // When value schema is optional, wrap in anyOf to allow undefined values
     const finalValueSchema = isValueOptional
-        ? { anyOf: [{ isUndefined: true }, valueJsonSchema] }
+        ? { ifDefined: valueJsonSchema }
         : valueJsonSchema;
     return new JObject([], {
         hasIsOfTypeCheck: false,
         keySchema: keyJsonSchema,
-        patternProperties: {
-            ['^.*$']: finalValueSchema,
-        },
+        additionalProperties: finalValueSchema,
     });
 }
 function withRegexKeys(keyRegex, schema) {

package/dist/validation/ajv/jsonSchemaBuilder.util.js

@@ -53,16 +53,20 @@ export function mergeJsonSchemaObjects(schema1, schema2) {
         s1.properties[k] = v;
     });
     // Merge `patternProperties`
-    Object.entries(s2.patternProperties || {}).forEach(([k, v]) => {
-        s1.patternProperties[k] = v;
-    });
+    if (s2.patternProperties) {
+        s1.patternProperties = { ...s1.patternProperties, ...s2.patternProperties };
+    }
     s1.propertyNames = s2.propertyNames || s1.propertyNames;
+    s1.keySchema = s2.keySchema || s1.keySchema;
     s1.minProperties = s2.minProperties ?? s1.minProperties;
     s1.maxProperties = s2.maxProperties ?? s1.maxProperties;
     // Merge `required`
     s1.required.push(...s2.required);
     s1.required = _uniq(s1.required).sort();
-    // `additionalProperties` remains the same
+    // `additionalProperties` remains the same, unless s2 is a string map (schema-valued)
+    if (typeof s2.additionalProperties === 'object') {
+        s1.additionalProperties = s2.additionalProperties;
+    }
     return _filterNullishValues(s1, { mutate: true });
 }
 export function isEveryItemString(arr) {

package/dist/zip/zipInternal.js

@@ -8,6 +8,7 @@ integer read/write helpers, DOS date/time conversion (both directions) and
 entry-name normalization/validation.
 
  */
+// oxlint-disable no-restricted-globals -- DOS date/time fields are local-time components, converted via the native Date
 // oxlint-disable no-bitwise -- the ZIP format packs DOS date/time into bit fields
 // Compression methods.
 export const STORED = 0;

package/dist/zip/zipWriter.js

@@ -29,6 +29,7 @@ import { finished, pipeline } from 'node:stream/promises';
 import { promisify } from 'node:util';
 import zlib from 'node:zlib';
 import { comparators } from '@naturalcycles/js-lib/array/sort.js';
+import { nowUnix } from '@naturalcycles/js-lib/datetime/localTime.js';
 import { _assert } from '@naturalcycles/js-lib/error/assert.js';
 import { glob } from 'tinyglobby';
 import { assertSafeZipEntryName, CDFH_SIG, CDFH_SIZE, DATA_DESCRIPTOR_SIG, DEFLATE, EOCDR_SIG, EOCDR_SIZE, LOCAL_FILE_HEADER_SIG, MAX_COMMENT_SIZE, normalizeZipEntryName, STORED, unixToDosDateTime, writeUInt64LE, ZIP64_EOCDL_SIG, ZIP64_EOCDL_SIZE, ZIP64_EOCDR_SIG, ZIP64_EOCDR_SIZE, } from './zipInternal.js';
@@ -222,7 +223,7 @@ export class ZipWriter {
         if (nameBuf.length > MAX_COMMENT_SIZE) {
             throw new Error(`zip entry name is too long: ${nameBuf.length} > ${MAX_COMMENT_SIZE} bytes`);
         }
-        const mtime = opt.mtime ?? Math.floor(Date.now() / 1000);
+        const mtime = opt.mtime ?? nowUnix();
         const { date, time } = unixToDosDateTime(mtime);
         const mode = opt.mode ?? (isDirectory ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE);
         if ((mode & 0xffff) !== mode) {