@blamejs/core 0.5.13 → 0.5.15

package/CHANGELOG.md

@@ -8,6 +8,8 @@ upgrading across more than a few patches at a time.
 
 ## v0.5.x
 
+- **0.5.14** (2026-04-30) — b.time: timezone-aware datetime arithmetic + formatting
+- **0.5.13** (2026-04-30) — b.testing.request: supertest-style chainable HTTP test helper
 - **0.5.12** (2026-04-30) — b.middleware.requestLog: HTTP access-log middleware
 - **0.5.11** (2026-04-30) — b.config: schema-validated environment configuration
 - **0.5.10** (2026-04-30) — b.middleware.sse: Server-Sent Events

package/index.js

@@ -105,9 +105,11 @@ var staticServe = require("./lib/static");
 var forms = require("./lib/forms");
 var app = require("./lib/app");
 var jobs = require("./lib/jobs");
+var archive = require("./lib/archive");
 var breakGlass = require("./lib/break-glass");
 var config = require("./lib/config");
 var csv = require("./lib/csv");
+var time = require("./lib/time");
 var uuid = require("./lib/uuid");
 var mail = require("./lib/mail");
 var mailBounce = require("./lib/mail-bounce");
@@ -210,9 +212,11 @@ module.exports = {
   forms:            forms,
   createApp:        app.createApp,
   jobs:             jobs,
+  archive:          archive,
   breakGlass:       breakGlass,
   config:           config,
   csv:              csv,
+  time:             time,
   uuid:             uuid,
   mail:             mail,
   mailBounce:       mailBounce,

package/lib/archive.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * archive — ZIP creation. Operator-data-export shape ("download my
+ * data as a zip"), log archives, plain-zip exports for users.
+ *
+ *   var archive = b.archive.zip();
+ *   archive.addFile("readme.txt",     "Hello\n");
+ *   archive.addFile("data/users.csv", csvBytes, { method: "deflate" });
+ *   archive.addFile("avatars/me.png", pngBuf,   { method: "store" });   // already-compressed
+ *   var zipBytes = archive.toBuffer();
+ *
+ *   // OR write directly to disk:
+ *   archive.writeTo("/tmp/export.zip");
+ *
+ * Format support:
+ *   - Stored (no compression — for already-compressed inputs like
+ *     PNG / JPEG / mp4)
+ *   - Deflate via node:zlib's deflateRawSync (default for everything else)
+ *   - File names with / are honored — directory entries are implicit;
+ *     extractors create the directory structure on demand
+ *   - UTF-8 file names (sets the EFS bit per APPNOTE 6.3.4)
+ *   - Modification time defaults to "now"; operators override per file
+ *
+ * v1 scope cuts (deferred):
+ *   - ZIP64 (>4 GiB archives, >65535 files) — operators with that
+ *     scale bring their own
+ *   - Encryption — `b.crypto.encryptPacked` produces a sealed bundle
+ *     for the operator's encryption-at-rest needs; ZIP-native
+ *     password encryption is broken-by-design
+ *   - Streaming write (toStream) — toBuffer() is enough for the
+ *     "download my data" shape; operators streaming gigabytes
+ *     have a different toolset
+ *   - Reading / extraction — write-only for now
+ */
+var zlib = require("node:zlib");
+var fs   = require("node:fs");
+var nodeCrypto = require("node:crypto");
+var { defineClass } = require("./framework-error");
+
+var ArchiveError = defineClass("ArchiveError", { alwaysPermanent: true });
+
+// ZIP signatures
+var SIG_LFH = 0x04034b50;   // local file header
+var SIG_CFH = 0x02014b50;   // central directory file header
+var SIG_EOCD = 0x06054b50;  // end of central directory
+
+// Compression methods
+var METHOD_STORE   = 0;
+var METHOD_DEFLATE = 8;
+
+// CRC-32 — IEEE 802.3 polynomial. node:crypto has no native CRC32, so
+// we vendor the standard table-driven implementation.
+var CRC32_TABLE = (function () {
+  var t = new Uint32Array(256);
+  for (var i = 0; i < 256; i++) {
+    var c = i;
+    for (var j = 0; j < 8; j++) c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+    t[i] = c >>> 0;
+  }
+  return t;
+})();
+
+function _crc32(buf) {
+  var crc = 0xffffffff;
+  for (var i = 0; i < buf.length; i++) {
+    crc = CRC32_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+// MS-DOS date/time encoding — APPNOTE 4.4.6
+function _msdosDateTime(date) {
+  var d = date instanceof Date ? date : new Date(date);
+  if (isNaN(d.getTime())) d = new Date();
+  var dosTime = ((d.getHours() & 0x1f) << 11) |
+                ((d.getMinutes() & 0x3f) << 5) |
+                ((Math.floor(d.getSeconds() / 2)) & 0x1f);
+  var dosDate = (((d.getFullYear() - 1980) & 0x7f) << 9) |
+                (((d.getMonth() + 1) & 0xf) << 5) |
+                (d.getDate() & 0x1f);
+  return { time: dosTime, date: dosDate };
+}
+
+function zip() {
+  var entries = [];
+
+  function addFile(name, content, opts) {
+    if (typeof name !== "string" || name.length === 0) {
+      throw new ArchiveError("archive/bad-name", "addFile: name must be a non-empty string");
+    }
+    if (name.indexOf("\0") !== -1) {
+      throw new ArchiveError("archive/bad-name", "addFile: name contains null byte");
+    }
+    // No path traversal — relative paths only, no leading slash, no ".." segments.
+    var normalized = name.replace(/\\/g, "/").replace(/^\/+/, "");
+    var segs = normalized.split("/");
+    for (var si = 0; si < segs.length; si++) {
+      if (segs[si] === "..") {
+        throw new ArchiveError("archive/bad-name", "addFile: name contains '..' segment");
+      }
+    }
+    var bodyBuf;
+    if (Buffer.isBuffer(content)) bodyBuf = content;
+    else if (typeof content === "string") bodyBuf = Buffer.from(content, "utf8");
+    else throw new ArchiveError("archive/bad-content",
+      "addFile: content must be a Buffer or string, got " + typeof content);
+
+    opts = opts || {};
+    var method = opts.method === "store" ? METHOD_STORE : METHOD_DEFLATE;
+    var mtime = opts.mtime instanceof Date ? opts.mtime : new Date();
+
+    var crc = _crc32(bodyBuf);
+    var stored = bodyBuf;
+    if (method === METHOD_DEFLATE) {
+      stored = zlib.deflateRawSync(bodyBuf);
+      // If deflate didn't shrink it (small/already-compressed inputs),
+      // fall back to STORE to save the operator a few bytes.
+      if (stored.length >= bodyBuf.length) {
+        stored = bodyBuf;
+        method = METHOD_STORE;
+      }
+    }
+
+    entries.push({
+      name:           normalized,
+      method:         method,
+      mtime:          mtime,
+      crc:            crc,
+      stored:         stored,
+      uncompressedSize: bodyBuf.length,
+    });
+  }
+
+  function _buildLocalFileHeader(entry) {
+    var nameBuf = Buffer.from(entry.name, "utf8");
+    var dt = _msdosDateTime(entry.mtime);
+    var hdr = Buffer.alloc(30);
+    hdr.writeUInt32LE(SIG_LFH, 0);
+    hdr.writeUInt16LE(20, 4);         // version needed
+    hdr.writeUInt16LE(0x0800, 6);     // flags: bit 11 = UTF-8 name
+    hdr.writeUInt16LE(entry.method, 8);
+    hdr.writeUInt16LE(dt.time, 10);
+    hdr.writeUInt16LE(dt.date, 12);
+    hdr.writeUInt32LE(entry.crc, 14);
+    hdr.writeUInt32LE(entry.stored.length, 18);
+    hdr.writeUInt32LE(entry.uncompressedSize, 22);
+    hdr.writeUInt16LE(nameBuf.length, 26);
+    hdr.writeUInt16LE(0, 28);         // extra field length
+    return Buffer.concat([hdr, nameBuf]);
+  }
+
+  function _buildCentralDirectoryEntry(entry, lfhOffset) {
+    var nameBuf = Buffer.from(entry.name, "utf8");
+    var dt = _msdosDateTime(entry.mtime);
+    var hdr = Buffer.alloc(46);
+    hdr.writeUInt32LE(SIG_CFH, 0);
+    hdr.writeUInt16LE(0x033f, 4);     // version made by (UNIX | 6.3)
+    hdr.writeUInt16LE(20, 6);         // version needed
+    hdr.writeUInt16LE(0x0800, 8);     // flags: bit 11 = UTF-8
+    hdr.writeUInt16LE(entry.method, 10);
+    hdr.writeUInt16LE(dt.time, 12);
+    hdr.writeUInt16LE(dt.date, 14);
+    hdr.writeUInt32LE(entry.crc, 16);
+    hdr.writeUInt32LE(entry.stored.length, 20);
+    hdr.writeUInt32LE(entry.uncompressedSize, 24);
+    hdr.writeUInt16LE(nameBuf.length, 28);
+    hdr.writeUInt16LE(0, 30);         // extra field length
+    hdr.writeUInt16LE(0, 32);         // file comment length
+    hdr.writeUInt16LE(0, 34);         // disk number start
+    hdr.writeUInt16LE(0, 36);         // internal file attributes
+    hdr.writeUInt32LE(0, 38);         // external file attributes
+    hdr.writeUInt32LE(lfhOffset, 42);
+    return Buffer.concat([hdr, nameBuf]);
+  }
+
+  function toBuffer() {
+    if (entries.length > 65535) {
+      throw new ArchiveError("archive/too-many-entries",
+        "ZIP archive cannot contain more than 65535 entries (ZIP64 unsupported in v1)");
+    }
+    var pieces = [];
+    var offsets = [];
+    var totalLocalBytes = 0;
+    for (var i = 0; i < entries.length; i++) {
+      offsets.push(totalLocalBytes);
+      var lfh = _buildLocalFileHeader(entries[i]);
+      pieces.push(lfh);
+      pieces.push(entries[i].stored);
+      totalLocalBytes += lfh.length + entries[i].stored.length;
+    }
+    var cdStart = totalLocalBytes;
+    var cdSize = 0;
+    for (var j = 0; j < entries.length; j++) {
+      var cdh = _buildCentralDirectoryEntry(entries[j], offsets[j]);
+      pieces.push(cdh);
+      cdSize += cdh.length;
+    }
+    // End of Central Directory
+    var eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(SIG_EOCD, 0);
+    eocd.writeUInt16LE(0, 4);                    // disk number
+    eocd.writeUInt16LE(0, 6);                    // disk where CD starts
+    eocd.writeUInt16LE(entries.length, 8);       // entries on this disk
+    eocd.writeUInt16LE(entries.length, 10);      // total entries
+    eocd.writeUInt32LE(cdSize, 12);              // size of central directory
+    eocd.writeUInt32LE(cdStart, 16);             // offset of central directory
+    eocd.writeUInt16LE(0, 20);                   // comment length
+    pieces.push(eocd);
+    return Buffer.concat(pieces);
+  }
+
+  function writeTo(filepath) {
+    var buf = toBuffer();
+    fs.writeFileSync(filepath, buf);
+    return buf.length;
+  }
+
+  function digest() {
+    // SHA-256 of the produced archive bytes — useful for operator-side
+    // integrity logging on exported bundles. Not vendor-locked to any
+    // particular hash; SHA-256 is universally recognized for content
+    // addressing.
+    return nodeCrypto.createHash("sha256").update(toBuffer()).digest("hex");
+  }
+
+  return {
+    addFile:    addFile,
+    toBuffer:   toBuffer,
+    writeTo:    writeTo,
+    digest:     digest,
+    get entryCount() { return entries.length; },
+  };
+}
+
+module.exports = {
+  zip:           zip,
+  ArchiveError:  ArchiveError,
+  // Test-only export — operators don't call this; it's here for unit-testing
+  // the CRC implementation against known vectors.
+  _crc32ForTest: _crc32,
+};

package/lib/time.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * time — timezone-aware datetime arithmetic + formatting on top of
+ * native `Intl.DateTimeFormat`. No TZ-database vendor; operators get
+ * the IANA names Node's ICU build supports (full set on every
+ * mainstream platform).
+ *
+ *   b.time.toParts(d, { timezone: "America/New_York" })
+ *     → { year, month, day, hour, minute, second, millisecond,
+ *         weekday: 1..7, weekdayName: "Mon"..."Sun", dayOfYear }
+ *
+ *   b.time.format(d, { timezone, locale, dateStyle, timeStyle })
+ *     → operator-readable string
+ *
+ *   b.time.startOfDay(d, { timezone })   → midnight in TZ
+ *   b.time.endOfDay(d, { timezone })     → 23:59:59.999 in TZ
+ *   b.time.addDays(d, n, { timezone })   → calendar-day add (DST-safe)
+ *   b.time.addMonths(d, n, { timezone }) → calendar-month add
+ *   b.time.diffDays(a, b, { timezone })  → calendar days between
+ *
+ *   b.time.parseISO(s)                   → Date | throws TimeError
+ *   b.time.tzOffsetMs(d, timezone)       → ms offset (= local - utc)
+ *
+ * All ops accept Date, ms-epoch number, or ISO 8601 string. `timezone`
+ * defaults to UTC. `locale` defaults to "en-US".
+ */
+var { defineClass } = require("./framework-error");
+
+var TimeError = defineClass("TimeError", { alwaysPermanent: true });
+
+var DEFAULT_TIMEZONE = "UTC";
+var DEFAULT_LOCALE   = "en-US";
+
+var _dtfCache = new Map();
+function _dtf(opts) {
+  var key = JSON.stringify(opts);
+  if (_dtfCache.has(key)) return _dtfCache.get(key);
+  var dtf;
+  try { dtf = new Intl.DateTimeFormat(opts.locale || DEFAULT_LOCALE, opts); }
+  catch (e) {
+    throw new TimeError("time/bad-timezone-or-locale",
+      "Intl rejected the timezone/locale: " + ((e && e.message) || String(e)));
+  }
+  _dtfCache.set(key, dtf);
+  return dtf;
+}
+
+function _toDate(v) {
+  if (v instanceof Date) {
+    if (isNaN(v.getTime())) {
+      throw new TimeError("time/invalid-date", "input Date is invalid (NaN)");
+    }
+    return v;
+  }
+  if (typeof v === "number") {
+    if (!isFinite(v)) {
+      throw new TimeError("time/invalid-ms", "input must be a finite number of milliseconds");
+    }
+    return new Date(v);
+  }
+  if (typeof v === "string") return parseISO(v);
+  throw new TimeError("time/bad-input",
+    "expected Date | number | ISO string, got " + typeof v);
+}
+
+var WEEKDAY_TO_NUM = {
+  "Mon": 1, "Tue": 2, "Wed": 3, "Thu": 4, "Fri": 5, "Sat": 6, "Sun": 7,
+};
+
+function toParts(input, opts) {
+  opts = opts || {};
+  var date = _toDate(input);
+  var tz = opts.timezone || DEFAULT_TIMEZONE;
+  var dtf = _dtf({
+    timeZone: tz,
+    year:    "numeric", month: "2-digit", day: "2-digit",
+    hour:    "2-digit", minute: "2-digit", second: "2-digit",
+    weekday: "short",
+    hour12:  false,
+  });
+  var parts = dtf.formatToParts(date);
+  var out = { millisecond: date.getUTCMilliseconds() };
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i];
+    if (p.type === "year")    out.year    = parseInt(p.value, 10);
+    if (p.type === "month")   out.month   = parseInt(p.value, 10);
+    if (p.type === "day")     out.day     = parseInt(p.value, 10);
+    if (p.type === "hour")    out.hour    = (p.value === "24" ? 0 : parseInt(p.value, 10));
+    if (p.type === "minute")  out.minute  = parseInt(p.value, 10);
+    if (p.type === "second")  out.second  = parseInt(p.value, 10);
+    if (p.type === "weekday") {
+      out.weekdayName = p.value;
+      out.weekday = WEEKDAY_TO_NUM[p.value] || null;
+    }
+  }
+  // dayOfYear: computed from out.year + out.month + out.day directly,
+  // no recursion through toParts. Days-in-month table for non-leap;
+  // Feb gets +1 in leap years (Gregorian rule: divisible by 4, not 100,
+  // unless 400).
+  var DAYS_BEFORE_MONTH = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
+  var leap = (out.year % 4 === 0 && out.year % 100 !== 0) || (out.year % 400 === 0);
+  out.dayOfYear = DAYS_BEFORE_MONTH[out.month - 1] + out.day + (leap && out.month > 2 ? 1 : 0);
+  return out;
+}
+
+function format(input, opts) {
+  opts = opts || {};
+  var date = _toDate(input);
+  var fmtOpts = {
+    timeZone: opts.timezone || DEFAULT_TIMEZONE,
+    locale:   opts.locale   || DEFAULT_LOCALE,
+  };
+  if (opts.dateStyle) fmtOpts.dateStyle = opts.dateStyle;
+  if (opts.timeStyle) fmtOpts.timeStyle = opts.timeStyle;
+  var passthroughKeys = [
+    "year", "month", "day", "hour", "minute", "second",
+    "weekday", "era", "hour12", "fractionalSecondDigits",
+    "timeZoneName",
+  ];
+  for (var i = 0; i < passthroughKeys.length; i++) {
+    var k = passthroughKeys[i];
+    if (opts[k] !== undefined) fmtOpts[k] = opts[k];
+  }
+  if (!opts.dateStyle && !opts.timeStyle && !passthroughKeys.some(function (k) { return opts[k] !== undefined; })) {
+    fmtOpts.dateStyle = "medium";
+    fmtOpts.timeStyle = "short";
+  }
+  return _dtf(fmtOpts).format(date);
+}
+
+function tzOffsetMs(input, timezone) {
+  var date = _toDate(input);
+  if (!timezone || typeof timezone !== "string") {
+    throw new TimeError("time/bad-timezone",
+      "tzOffsetMs: timezone must be a non-empty IANA name");
+  }
+  var dtf = _dtf({
+    timeZone: timezone,
+    year: "numeric", month: "2-digit", day: "2-digit",
+    hour: "2-digit", minute: "2-digit", second: "2-digit",
+    hour12: false,
+  });
+  var parts = {};
+  dtf.formatToParts(date).forEach(function (p) { parts[p.type] = p.value; });
+  var hour = parts.hour === "24" ? "00" : parts.hour;
+  var asUtcMs = Date.UTC(
+    parseInt(parts.year, 10),
+    parseInt(parts.month, 10) - 1,
+    parseInt(parts.day, 10),
+    parseInt(hour, 10),
+    parseInt(parts.minute, 10),
+    parseInt(parts.second, 10)
+  );
+  var instantSec = Math.floor(date.getTime() / 1000) * 1000;
+  return asUtcMs - instantSec;
+}
+
+function _fromPartsAtTz(p, timezone) {
+  var candidate = Date.UTC(
+    p.year,
+    (p.month - 1),
+    p.day,
+    p.hour    || 0,
+    p.minute  || 0,
+    p.second  || 0,
+    p.millisecond || 0
+  );
+  var offset1 = tzOffsetMs(candidate, timezone);
+  var step1   = candidate - offset1;
+  var offset2 = tzOffsetMs(step1, timezone);
+  return new Date(step1 - (offset2 - offset1));
+}
+
+function startOfDay(input, opts) {
+  opts = opts || {};
+  var tz = opts.timezone || DEFAULT_TIMEZONE;
+  var p = toParts(input, { timezone: tz });
+  return _fromPartsAtTz({
+    year: p.year, month: p.month, day: p.day,
+    hour: 0, minute: 0, second: 0, millisecond: 0,
+  }, tz);
+}
+
+function endOfDay(input, opts) {
+  opts = opts || {};
+  var tz = opts.timezone || DEFAULT_TIMEZONE;
+  var p = toParts(input, { timezone: tz });
+  return _fromPartsAtTz({
+    year: p.year, month: p.month, day: p.day,
+    hour: 23, minute: 59, second: 59, millisecond: 999,
+  }, tz);
+}
+
+function addDays(input, n, opts) {
+  opts = opts || {};
+  if (typeof n !== "number" || !isFinite(n)) {
+    throw new TimeError("time/bad-arg", "addDays: n must be a finite number");
+  }
+  var tz = opts.timezone || DEFAULT_TIMEZONE;
+  var p = toParts(input, { timezone: tz });
+  var asUtc = new Date(Date.UTC(p.year, p.month - 1, p.day + Math.trunc(n),
+    p.hour, p.minute, p.second, p.millisecond));
+  return _fromPartsAtTz({
+    year:        asUtc.getUTCFullYear(),
+    month:       asUtc.getUTCMonth() + 1,
+    day:         asUtc.getUTCDate(),
+    hour:        p.hour, minute: p.minute, second: p.second, millisecond: p.millisecond,
+  }, tz);
+}
+
+function addMonths(input, n, opts) {
+  opts = opts || {};
+  if (typeof n !== "number" || !isFinite(n)) {
+    throw new TimeError("time/bad-arg", "addMonths: n must be a finite number");
+  }
+  var tz = opts.timezone || DEFAULT_TIMEZONE;
+  var p = toParts(input, { timezone: tz });
+  var newMonth0 = (p.month - 1) + Math.trunc(n);
+  var newYear   = p.year + Math.floor(newMonth0 / 12);
+  newMonth0     = ((newMonth0 % 12) + 12) % 12;
+  var daysInNew = new Date(Date.UTC(newYear, newMonth0 + 1, 0)).getUTCDate();
+  var newDay    = Math.min(p.day, daysInNew);
+  return _fromPartsAtTz({
+    year: newYear, month: newMonth0 + 1, day: newDay,
+    hour: p.hour, minute: p.minute, second: p.second, millisecond: p.millisecond,
+  }, tz);
+}
+
+function diffDays(a, b, opts) {
+  opts = opts || {};
+  var tz = opts.timezone || DEFAULT_TIMEZONE;
+  var aMid = startOfDay(a, { timezone: tz });
+  var bMid = startOfDay(b, { timezone: tz });
+  return Math.round((bMid.getTime() - aMid.getTime()) / 86400000);
+}
+
+var ISO_RE = /^(\d{4})-(\d{2})-(\d{2})(?:[T\s](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+
+function parseISO(s) {
+  if (typeof s !== "string" || s.length === 0) {
+    throw new TimeError("time/bad-iso", "parseISO: input must be a non-empty string");
+  }
+  var m = ISO_RE.exec(s);
+  if (!m) {
+    throw new TimeError("time/bad-iso",
+      "parseISO: not an ISO 8601 datetime: " + JSON.stringify(s));
+  }
+  var year   = parseInt(m[1], 10);
+  var month  = parseInt(m[2], 10);
+  var day    = parseInt(m[3], 10);
+  var hour   = m[4] ? parseInt(m[4], 10) : 0;
+  var minute = m[5] ? parseInt(m[5], 10) : 0;
+  var second = m[6] ? parseInt(m[6], 10) : 0;
+  var msStr  = m[7] || "";
+  var ms     = msStr ? parseInt((msStr + "000").slice(0, 3), 10) : 0;
+  var tz     = m[8];
+
+  if (month < 1 || month > 12 || day < 1 || day > 31 ||
+      hour > 23 || minute > 59 || second > 59) {
+    throw new TimeError("time/bad-iso",
+      "parseISO: out-of-range component in " + JSON.stringify(s));
+  }
+  var utcMs;
+  if (!tz) {
+    utcMs = Date.UTC(year, month - 1, day, hour, minute, second, ms);
+  } else if (tz === "Z") {
+    utcMs = Date.UTC(year, month - 1, day, hour, minute, second, ms);
+  } else {
+    var sign = tz.charAt(0) === "-" ? -1 : 1;
+    var hh   = parseInt(tz.slice(1, 3), 10);
+    var mm   = parseInt(tz.slice(tz.length - 2), 10);
+    var offsetMs = sign * (hh * 3600 + mm * 60) * 1000;
+    utcMs = Date.UTC(year, month - 1, day, hour, minute, second, ms) - offsetMs;
+  }
+  return new Date(utcMs);
+}
+
+module.exports = {
+  toParts:      toParts,
+  format:       format,
+  tzOffsetMs:   tzOffsetMs,
+  startOfDay:   startOfDay,
+  endOfDay:     endOfDay,
+  addDays:      addDays,
+  addMonths:    addMonths,
+  diffDays:     diffDays,
+  parseISO:     parseISO,
+  TimeError:    TimeError,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.5.13",
+  "version": "0.5.15",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",