@ai-ecoverse/slicc-kernel 1.174.1 → 1.174.3

package/dist/kernel-worker.js

@@ -8740,7 +8740,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.174.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.174.3" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -9152,6 +9152,27 @@ function binfmtOf(binfmts, path) {
   return best === void 0 ? void 0 : binfmts.get(best);
 }
 
+// src/cron/clock.ts
+function clockZone(clock) {
+  return clock?.timeZone ?? (clock?.utc === true ? "UTC" : void 0);
+}
+var systemCronClock = {
+  now: () => Date.now(),
+  sleep(until2, signal) {
+    if (signal.aborted) return Promise.resolve();
+    return new Promise((resolve2) => {
+      const done5 = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", done5);
+        resolve2();
+      };
+      const timer = setTimeout(done5, Math.max(0, until2 - Date.now()));
+      timer.unref?.();
+      signal.addEventListener("abort", done5, { once: true });
+    });
+  }
+};
+
 // src/cron/command.ts
 var CRONTAB_PATH = "/usr/bin/crontab";
 var CRONTAB_COMMAND = {
@@ -9263,6 +9284,94 @@ var CRONTAB_SOURCE = `export default async function crontab(ctx) {
 }
 `;
 
+// src/time-zone.ts
+var MINUTE_MS = 6e4;
+var HOUR_MS = 60 * MINUTE_MS;
+var BUCKET_MS = 15 * MINUTE_MS;
+var CACHE_MAX = 4096;
+var ZERO = /* @__PURE__ */ new Set(["UTC", "Etc/UTC", "Etc/GMT", "GMT", "Etc/Universal", "Etc/Zulu"]);
+function canonicalZone(name2) {
+  if (typeof name2 !== "string" || name2 === "" || name2.length > 64) return void 0;
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: name2 }).resolvedOptions().timeZone;
+  } catch {
+    return void 0;
+  }
+}
+function hostTimeZone() {
+  let name2;
+  try {
+    name2 = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    name2 = void 0;
+  }
+  return canonicalZone(name2) ?? "UTC";
+}
+function systemTimeZone(given, fallback) {
+  if (given !== void 0) {
+    const zone = canonicalZone(given);
+    if (zone === void 0) throw new Error(`not a time zone: ${String(given)}`);
+    return zone;
+  }
+  return canonicalZone(fallback) ?? hostTimeZone();
+}
+var utcZone = { name: "UTC", offset: () => 0 };
+function hostZone(name2) {
+  return { name: name2, offset: (at) => -new Date(at).getTimezoneOffset() * MINUTE_MS };
+}
+function intlZone(name2) {
+  const format = new Intl.DateTimeFormat("en-US", {
+    timeZone: name2,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  });
+  const exact = (at) => {
+    const parts2 = {};
+    for (const part of format.formatToParts(at)) parts2[part.type] = Number(part.value);
+    const wall = Date.UTC(
+      parts2.year,
+      parts2.month - 1,
+      parts2.day,
+      parts2.hour,
+      parts2.minute,
+      parts2.second
+    );
+    return wall - Math.floor(at / 1e3) * 1e3;
+  };
+  const buckets = /* @__PURE__ */ new Map();
+  return {
+    name: name2,
+    offset(at) {
+      const bucket = Math.floor(at / BUCKET_MS);
+      let known = buckets.get(bucket);
+      if (known === void 0) {
+        const start2 = exact(bucket * BUCKET_MS);
+        known = start2 === exact(bucket * BUCKET_MS + BUCKET_MS - MINUTE_MS) ? start2 : null;
+        if (buckets.size >= CACHE_MAX) buckets.clear();
+        buckets.set(bucket, known);
+      }
+      return known ?? exact(at);
+    }
+  };
+}
+var zones = /* @__PURE__ */ new Map();
+function zoneOf(name2) {
+  if (ZERO.has(name2)) return utcZone;
+  if (name2 === hostTimeZone()) return hostZone(name2);
+  let zone = zones.get(name2);
+  if (!zone) {
+    zone = intlZone(name2);
+    zones.set(name2, zone);
+  }
+  return zone;
+}
+var MAX_SHIFT_MS = 3 * HOUR_MS;
+
 // src/cron/schedule.ts
 var MISSED_CAP = 1e5;
 var MACROS = {
@@ -9334,6 +9443,7 @@ function parseSchedule(expression) {
   );
   if (weekdays.delete(7)) weekdays.add(0);
   return {
+    fixed: !parts2[0].startsWith("*") && !parts2[1].startsWith("*"),
     minutes,
     hours,
     days,
@@ -9347,18 +9457,6 @@ function parseWhen(expression) {
   if (expression.trim().toLowerCase() === "@reboot") return { reboot: true };
   return { reboot: false, schedule: parseSchedule(expression) };
 }
-var LOCAL = {
-  year: (d) => d.getFullYear(),
-  month: (d) => d.getMonth(),
-  date: (d) => d.getDate(),
-  day: (d) => d.getDay(),
-  hours: (d) => d.getHours(),
-  minutes: (d) => d.getMinutes(),
-  setMonth: (d, month) => d.setMonth(month, 1),
-  setDate: (d, date) => d.setDate(date),
-  setHours: (d, hours) => d.setHours(hours, 0, 0, 0),
-  setMinutes: (d, minutes) => d.setMinutes(minutes, 0, 0)
-};
 var UTC = {
   year: (d) => d.getUTCFullYear(),
   month: (d) => d.getUTCMonth(),
@@ -9371,60 +9469,112 @@ var UTC = {
   setHours: (d, hours) => d.setUTCHours(hours, 0, 0, 0),
   setMinutes: (d, minutes) => d.setUTCMinutes(minutes, 0, 0)
 };
-function dayMatches(schedule, cal, date) {
-  const day = schedule.days.has(cal.date(date));
-  const weekday = schedule.weekdays.has(cal.day(date));
+function dayMatches(schedule, date) {
+  const day = schedule.days.has(UTC.date(date));
+  const weekday = schedule.weekdays.has(UTC.day(date));
   if (schedule.anyDay || schedule.anyWeekday) return day && weekday;
   return day || weekday;
 }
 var LIMIT_YEARS = 8;
-function nextFire(schedule, after, utc = false) {
-  const cal = utc ? UTC : LOCAL;
-  const date = new Date(Math.floor(after / 6e4) * 6e4 + 6e4);
-  const limit = cal.year(date) + LIMIT_YEARS;
-  while (cal.year(date) <= limit) {
-    if (!schedule.months.has(cal.month(date) + 1)) {
-      cal.setMonth(date, cal.month(date) + 1);
-      cal.setHours(date, 0);
-    } else if (!dayMatches(schedule, cal, date)) {
-      cal.setDate(date, cal.date(date) + 1);
-      cal.setHours(date, 0);
-    } else if (!schedule.hours.has(cal.hours(date))) {
-      cal.setHours(date, cal.hours(date) + 1);
-    } else if (!schedule.minutes.has(cal.minutes(date))) {
-      cal.setMinutes(date, cal.minutes(date) + 1);
+var LIMIT_MS = (LIMIT_YEARS + 1) * 366 * 24 * 60 * MINUTE_MS;
+var SCAN_MS = 6 * 60 * MINUTE_MS;
+function nextWall(schedule, from) {
+  const date = new Date(Math.ceil(from / MINUTE_MS) * MINUTE_MS);
+  const limit = UTC.year(date) + LIMIT_YEARS;
+  while (UTC.year(date) <= limit) {
+    if (!schedule.months.has(UTC.month(date) + 1)) {
+      UTC.setMonth(date, UTC.month(date) + 1);
+      UTC.setHours(date, 0);
+    } else if (!dayMatches(schedule, date)) {
+      UTC.setDate(date, UTC.date(date) + 1);
+      UTC.setHours(date, 0);
+    } else if (!schedule.hours.has(UTC.hours(date))) {
+      UTC.setHours(date, UTC.hours(date) + 1);
+    } else if (!schedule.minutes.has(UTC.minutes(date))) {
+      UTC.setMinutes(date, UTC.minutes(date) + 1);
     } else return date.getTime();
   }
   return null;
 }
-function missedFires(schedule, from, until2, utc = false, cap = MISSED_CAP) {
+function firstChange(zone, from, to, offset) {
+  let lo = from;
+  let hi = to;
+  for (let at = from + SCAN_MS; at < to; at += SCAN_MS) {
+    if (zone.offset(at) !== offset) {
+      hi = at;
+      break;
+    }
+    lo = at;
+  }
+  while (hi - lo > MINUTE_MS) {
+    const mid = lo + Math.floor((hi - lo) / 2 / MINUTE_MS) * MINUTE_MS;
+    if (zone.offset(mid) === offset) lo = mid;
+    else hi = mid;
+  }
+  return hi;
+}
+function afterRepeat(zone, at) {
+  const offset = zone.offset(at);
+  const earlier = zone.offset(at - MAX_SHIFT_MS);
+  if (earlier <= offset) return at;
+  const shift = firstChange(zone, at - MAX_SHIFT_MS, at, earlier);
+  const end = shift + (earlier - zone.offset(shift));
+  return Math.max(at, end);
+}
+function nextFire(schedule, after, zone = utcZone) {
+  let at = Math.floor(after / MINUTE_MS) * MINUTE_MS + MINUTE_MS;
+  const limit = at + LIMIT_MS;
+  while (at <= limit) {
+    if (schedule.fixed) {
+      const end = afterRepeat(zone, at);
+      if (end > at) {
+        at = end;
+        continue;
+      }
+    }
+    const offset = zone.offset(at);
+    const before = zone.offset(at - MINUTE_MS);
+    if (schedule.fixed && before < offset && offset - before <= MAX_SHIFT_MS) {
+      const skipped = nextWall(schedule, at + before);
+      if (skipped !== null && skipped < at + offset) return at;
+    }
+    const wall = nextWall(schedule, at + offset);
+    if (wall === null) return null;
+    const found = at + (wall - (at + offset));
+    const change = firstChange(zone, at, found, offset);
+    if (change >= found && zone.offset(found) === offset) return found;
+    at = change;
+  }
+  return null;
+}
+function missedFires(schedule, from, until2, zone = utcZone, cap = MISSED_CAP) {
   let count2 = 0;
   let last = null;
   let at = from;
   while (count2 < cap) {
-    at = nextFire(schedule, at, utc);
+    at = nextFire(schedule, at, zone);
     if (at === null || at > until2) return { count: count2, last, more: false };
     last = at;
     count2++;
   }
-  const next3 = nextFire(schedule, last, utc);
+  const next3 = nextFire(schedule, last, zone);
   if (next3 === null || next3 > until2) return { count: count2, last, more: false };
-  return { count: count2, last: latestFire(schedule, last, until2, utc), more: true };
+  return { count: count2, last: latestFire(schedule, last, until2, zone), more: true };
 }
-function latestFire(schedule, from, until2, utc = false) {
+function latestFire(schedule, from, until2, zone = utcZone) {
   let found = from;
   for (let span = 6e4; ; span *= 2) {
     const start2 = Math.max(from, until2 - span);
-    const first = nextFire(schedule, start2, utc);
+    const first = nextFire(schedule, start2, zone);
     if (first !== null && first <= until2) {
       found = first;
       break;
     }
     if (start2 === from) return from;
   }
-  for (let at = nextFire(schedule, found, utc); at !== null && at <= until2; ) {
+  for (let at = nextFire(schedule, found, zone); at !== null && at <= until2; ) {
     found = at;
-    at = nextFire(schedule, at, utc);
+    at = nextFire(schedule, at, zone);
   }
   return found;
 }
@@ -9465,13 +9615,16 @@ function split2(text, count2) {
   }
   return [words2, rest2.trim()];
 }
-function jobOf(content, pending, ctx) {
+function jobOf(content, pending, ctx, env) {
   const fields = content.startsWith("@") ? 1 : 5;
   const parts2 = split2(content, fields + (ctx.system ? 1 : 0));
   if (!parts2 || parts2[1] === "") throw new Error("no command");
   const [words2, command] = parts2;
   const schedule = words2.slice(0, fields).join(" ");
   const when = parseWhen(schedule);
+  const zone = env.CRON_TZ;
+  if (zone && !when.reboot && canonicalZone(zone) === void 0)
+    throw new Error(`CRON_TZ: unknown time zone "${zone}"`);
   const user = ctx.system ? words2[fields] : void 0;
   if (user !== void 0 && !USER_NAME.test(user)) throw new Error(`bad user name ${user}`);
   if (pending !== void 0 && !JOB_NAME.test(pending))
@@ -9517,7 +9670,7 @@ function parseCrontab(text, path, system = false) {
       continue;
     }
     try {
-      jobs.push({ line, ...jobOf(content, pending, ctx), env: { ...env } });
+      jobs.push({ line, ...jobOf(content, pending, ctx, env), env: { ...env } });
     } catch (err) {
       errors.push({ line, message: err.message });
     }
@@ -10304,24 +10457,6 @@ var UnlinkedKeeper = class {
   }
 };
 
-// src/cron/clock.ts
-var systemCronClock = {
-  now: () => Date.now(),
-  sleep(until2, signal) {
-    if (signal.aborted) return Promise.resolve();
-    return new Promise((resolve2) => {
-      const done5 = () => {
-        clearTimeout(timer);
-        signal.removeEventListener("abort", done5);
-        resolve2();
-      };
-      const timer = setTimeout(done5, Math.max(0, until2 - Date.now()));
-      timer.unref?.();
-      signal.addEventListener("abort", done5, { once: true });
-    });
-  }
-};
-
 // src/cron/service.ts
 var CRON_DIR = "/var/spool/cron";
 var STAMP_PATH = `${CRON_DIR}/stamp`;
@@ -10333,9 +10468,10 @@ var WAKE_MS = 6e4;
 var BACK_JUMP_MS = 12e4;
 var DEFAULT_SHELL = "/bin/bash";
 var encoder = new TextEncoder();
-var EMPTY_STAMP = JSON.stringify({ jobs: {}, reboot: {} });
+var EMPTY_STAMP = JSON.stringify({ jobs: {}, reboot: {}, when: {} });
 var messageOf = (err) => err?.message ?? String(err);
 var keyOf2 = ({ source, job }) => `${source}	${job.id}`;
+var whenOf = ({ job }) => `${job.schedule}	${job.env.CRON_TZ ?? ""}`;
 function tail(bytes, cap = LOG_CAP) {
   return bytes.length > cap ? bytes.slice(bytes.length - cap) : bytes;
 }
@@ -10369,9 +10505,10 @@ function readStamp(text) {
     const parsed2 = JSON.parse(text ?? "");
     const jobs = parsed2.jobs && typeof parsed2.jobs === "object" ? parsed2.jobs : {};
     const reboot = parsed2.reboot && typeof parsed2.reboot === "object" ? parsed2.reboot : {};
-    return { jobs: { ...jobs }, reboot: { ...reboot } };
+    const when = parsed2.when && typeof parsed2.when === "object" ? parsed2.when : {};
+    return { jobs: { ...jobs }, reboot: { ...reboot }, when: { ...when } };
   } catch {
-    return { jobs: {}, reboot: {} };
+    return { jobs: {}, reboot: {}, when: {} };
   }
 }
 var CronService = class {
@@ -10446,7 +10583,7 @@ var CronService = class {
     const loaded = await this.load();
     const stamp = readStamp(await fs.readFile(STAMP_PATH).catch(() => void 0));
     const now = this.clock.now();
-    const utc = this.clock.utc === true;
+    const system = this.host.timeZone;
     const due2 = [];
     const keys = /* @__PURE__ */ new Set();
     let next3 = now + WAKE_MS;
@@ -10460,20 +10597,24 @@ var CronService = class {
         due2.push({ entry, due: now, missed: 0 });
         continue;
       }
+      const zone = zoneOf(entry.job.env.CRON_TZ || system);
       const last = stamp.jobs[key];
-      if (typeof last !== "number" || last > now + BACK_JUMP_MS) stamp.jobs[key] = now;
+      const was = stamp.when[key];
+      stamp.when[key] = whenOf(entry);
+      const changed = was !== void 0 && was !== stamp.when[key];
+      if (typeof last !== "number" || changed || last > now + BACK_JUMP_MS) stamp.jobs[key] = now;
       else {
-        const missed = missedFires(when.schedule, last, now, utc);
+        const missed = missedFires(when.schedule, last, now, zone);
         if (missed.last !== null) {
           stamp.jobs[key] = now;
           due2.push({ entry, due: missed.last, missed: missed.count - 1 });
         }
       }
-      const coming = nextFire(when.schedule, Math.max(now, stamp.jobs[key]), utc);
+      const coming = nextFire(when.schedule, Math.max(now, stamp.jobs[key]), zone);
       if (coming !== null && coming < next3) next3 = coming;
     }
     this.rebooted = true;
-    for (const map of [stamp.jobs, stamp.reboot])
+    for (const map of [stamp.jobs, stamp.reboot, stamp.when])
       for (const key of Object.keys(map)) if (!keys.has(key)) delete map[key];
     await this.writeStamp(stamp);
     for (const each of due2) void this.spawn(each);
@@ -16212,14 +16353,14 @@ function attachSyncSabResponder(port, sab, token, opts) {
 
 // src/kernel/cpu-clock.ts
 var SYS_CAP_US = 2e4;
-var LOCAL2 = SAB_CLOCK_OFFSET;
+var LOCAL = SAB_CLOCK_OFFSET;
 var BLOCKED = 0;
 var IDLE = 1;
 function epochMicros() {
   return Math.floor((performance.timeOrigin + performance.now()) * 1e3);
 }
 function slots(sab) {
-  return new BigInt64Array(sab, LOCAL2, SAB_CLOCK_I64);
+  return new BigInt64Array(sab, LOCAL, SAB_CLOCK_I64);
 }
 var rawWait = Atomics.wait.bind(Atomics);
 function localIdle(sab, now) {
@@ -33068,6 +33209,7 @@ var Launcher = class {
   routes;
   resolver;
   hostname;
+  timeZone;
   watchers = new FsWatchers();
   changes = new FileChanges();
   peerHeldPaths = /* @__PURE__ */ new Set();
@@ -33183,9 +33325,11 @@ var Launcher = class {
     const hostname = options.hostname ?? DEFAULT_HOSTNAME;
     if (!isHostname(hostname)) throw new Error(`not a host name: ${String(hostname)}`);
     this.hostname = hostname;
+    this.timeZone = systemTimeZone(options.timeZone, clockZone(options.cron?.clock));
     this.env = {
       ...networkEnv(hostname),
       HOSTNAME: hostname,
+      TZ: this.timeZone,
       SLICC_CDP_URL: this.cdp.url,
       ...this.facades.env(),
       ...options.env
@@ -33295,6 +33439,7 @@ var Launcher = class {
       owners: this.owners,
       lock: options.lock ?? "slicc-kernel-cron",
       bootId: this.bootId,
+      timeZone: this.timeZone,
       ...options.clock ? { clock: options.clock } : {},
       locks: cronLocks(),
       ready: () => this.fstab,
@@ -35314,7 +35459,7 @@ var Launcher = class {
   }
   environment(cwd, extra, account, login2 = false) {
     const env = {
-      ...login2 ? { ...networkEnv(this.hostname), HOSTNAME: this.hostname } : this.env,
+      ...login2 ? { ...networkEnv(this.hostname), HOSTNAME: this.hostname, TZ: this.timeZone } : this.env,
       ...userEnv(account, this.pnpmHome),
       PWD: cwd,
       ...extra
@@ -36167,6 +36312,7 @@ function hostOptions(req, port, sealed, sealedFetch, clipboard, lookup2, request
   return {
     cron: { lock: `slicc-kernel-cron:${req.metadata ?? META_DB}` },
     ...req.hostname !== void 0 ? { hostname: req.hostname } : {},
+    ...req.timeZone !== void 0 ? { timeZone: req.timeZone } : {},
     ...req.doh !== void 0 ? { doh: req.doh } : {},
     ...req.users !== void 0 ? { users: req.users } : {},
     ...req.denials ? { onDenial: (denial) => port.postMessage({ denial }) } : {},