@poe-platform/safe-js 0.1.287 → 0.1.289

package/README.md

@@ -103,8 +103,6 @@ Current-time reads are recorded for replay; replay does not call `now()` again.
 
 Date values copy by value across host bindings, preserving aliases within a graph. Checkpoints preserve epoch values, invalid dates and mutations rather than converting dates to strings. Parsing is limited to 4,096 characters and consumes the work/string budgets; retained values consume data budget. Local methods and non-ISO parsing follow the host timezone/runtime, so use explicit-zone ISO strings and UTC methods for portable output.
 
-Unsupported: locale formatting, legacy `getYear`/`setYear`/`toGMTString`, subclassing, custom argument coercion, Date-instance own properties and prototype modification. These are restrictions, not stubs; no native constructor or prototype is exposed to guest code.
-
 </details>
 
 ## Add a host capability

package/dist/safe-js/chunks/{chunk-OZBMCFTD.js → chunk-BNVOTMJ4.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-OK6MNHBQ.js";
+} from "./chunk-KKMT52LR.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-OZBMCFTD.js.map
+//# sourceMappingURL=chunk-BNVOTMJ4.js.map

package/dist/safe-js/chunks/{chunk-OK6MNHBQ.js → chunk-KKMT52LR.js}

@@ -6933,6 +6933,7 @@ var methodNames = [
   "getDate",
   "getDay",
   "getFullYear",
+  "getYear",
   "getHours",
   "getMilliseconds",
   "getMinutes",
@@ -6950,6 +6951,7 @@ var methodNames = [
   "setTime",
   "setDate",
   "setFullYear",
+  "setYear",
   "setHours",
   "setMilliseconds",
   "setMinutes",
@@ -6964,6 +6966,9 @@ var methodNames = [
   "setUTCSeconds",
   "toDateString",
   "toISOString",
+  "toLocaleString",
+  "toLocaleDateString",
+  "toLocaleTimeString",
   "toString",
   "toTimeString",
   "toUTCString",
@@ -6971,7 +6976,7 @@ var methodNames = [
 ];
 var dateMethods = new Map(
   methodNames.map((name) => {
-    const native = NativeDate.prototype[name];
+    const native = Object.getOwnPropertyDescriptor(NativeDate.prototype, name).value;
     return [
       name,
       {
@@ -20364,6 +20369,111 @@ async function parseJsonWithReviver(text, reviver, budget, context) {
   }
 }
 
+// packages/safe-js/src/interp/date-locale.ts
+var NativeDateTimeFormat = Intl.DateTimeFormat;
+var canonicalLocales = Intl.getCanonicalLocales;
+var dateTimeOptions = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["calendar", "unicodeType"],
+  ["numberingSystem", "unicodeType"],
+  ["hour12", "boolean"],
+  ["hourCycle", ["h11", "h12", "h23", "h24"]],
+  ["timeZone", "zone"],
+  ["weekday", ["narrow", "short", "long"]],
+  ["era", ["narrow", "short", "long"]],
+  ["year", ["2-digit", "numeric"]],
+  ["month", ["2-digit", "numeric", "narrow", "short", "long"]],
+  ["day", ["2-digit", "numeric"]],
+  ["dayPeriod", ["narrow", "short", "long"]],
+  ["hour", ["2-digit", "numeric"]],
+  ["minute", ["2-digit", "numeric"]],
+  ["second", ["2-digit", "numeric"]],
+  ["fractionalSecondDigits", "number"],
+  ["timeZoneName", ["short", "long", "shortOffset", "longOffset", "shortGeneric", "longGeneric"]],
+  ["formatMatcher", ["basic", "best fit"]],
+  ["dateStyle", ["full", "long", "medium", "short"]],
+  ["timeStyle", ["full", "long", "medium", "short"]]
+];
+async function formatDateLocale(name, time, args, budget, context) {
+  if (Number.isNaN(time)) return budget.allocateString("Invalid Date");
+  const locales = [];
+  const options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [locales, options]);
+  const read = (value, key) => {
+    budget.visitNode();
+    if (context?.getProperty !== void 0) return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  };
+  const toObject = (value) => {
+    if (value === null || value === void 0) throw new TypeError("Cannot convert null or undefined to an object.");
+    if (typeof value === "object") return value;
+    const box = createSandboxBox(value);
+    allocateProducedSandboxValue(box, budget);
+    return box;
+  };
+  try {
+    const inputLocales = args[0];
+    if (inputLocales !== void 0) {
+      const list2 = typeof inputLocales === "string" ? [inputLocales] : toObject(inputLocales);
+      const count = await sandboxNumber(await read(list2, "length"), budget, context);
+      const length = Number.isNaN(count) || count <= 0 ? 0 : Math.min(Math.floor(count), Number.MAX_SAFE_INTEGER);
+      for (let index = 0; index < length; index++) {
+        budget.visitNode();
+        const key = String(index);
+        if (getSandboxPropertyDescriptor(list2, key, budget) === void 0 && !(isFloat32Array(list2) && Object.hasOwn(list2, key))) continue;
+        const value = await read(list2, key);
+        if (typeof value !== "string" && (typeof value !== "object" || value === null))
+          throw new TypeError("Locale entries must be strings or objects.");
+        const tag = await sandboxString(value, budget, context);
+        budget.visitNode(tag.length);
+        const canonical = canonicalLocales(tag)[0];
+        budget.visitNode(locales.length);
+        if (!locales.includes(canonical)) locales.push(budget.allocateString(canonical));
+      }
+    }
+    const inputOptions = args[1] === void 0 ? /* @__PURE__ */ Object.create(null) : toObject(args[1]);
+    for (const [key, type] of dateTimeOptions) {
+      const value = await read(inputOptions, key);
+      if (value === void 0) continue;
+      if (type === "boolean") options[key] = Boolean(value);
+      else if (type === "number") {
+        const number = await sandboxNumber(value, budget, context);
+        if (!Number.isFinite(number) || number < 1 || number > 3)
+          throw new RangeError("fractionalSecondDigits must be between 1 and 3.");
+        options[key] = Math.floor(number);
+      } else {
+        const text = await sandboxString(value, budget, context);
+        budget.visitNode(text.length);
+        if (type === "unicodeType") {
+          const valid = text.split("-").every((part) => part.length >= 3 && part.length <= 8 && [...part].every((char) => char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9"));
+          if (!valid) throw new RangeError(`Invalid ${key} option.`);
+        } else if (type === "zone") {
+          new NativeDateTimeFormat("en", { timeZone: text });
+        } else if (!type.includes(text)) throw new RangeError(`Invalid ${key} option.`);
+        options[key] = text;
+      }
+    }
+    const date = name !== "toLocaleTimeString";
+    const clock = name !== "toLocaleDateString";
+    if (options.dateStyle !== void 0 || options.timeStyle !== void 0) {
+      if (!date && options.dateStyle !== void 0 || !clock && options.timeStyle !== void 0)
+        throw new TypeError("Date/time style is incompatible with this locale method.");
+    } else {
+      const hasDate = date && ["weekday", "year", "month", "day"].some((key) => options[key] !== void 0);
+      const hasTime = clock && ["dayPeriod", "hour", "minute", "second", "fractionalSecondDigits"].some((key) => options[key] !== void 0);
+      if (!hasDate && !hasTime) {
+        if (date) for (const key of ["year", "month", "day"]) options[key] = "numeric";
+        if (clock) for (const key of ["hour", "minute", "second"]) options[key] = "numeric";
+      }
+    }
+    const formatter = new NativeDateTimeFormat(locales, options);
+    return budget.allocateString(formatter.format(time));
+  } finally {
+    release();
+  }
+}
+
 // packages/safe-js/src/snapshot/replay-data.ts
 var MissingReplayCapabilityError = class extends TypeError {
 };
@@ -21941,12 +22051,14 @@ function createDateGlobal(options) {
           if (!isSandboxDate(receiver))
             throw new TypeError(`Date#${name} requires a Date receiver.`);
           options.budget.visitNode();
+          if (name.startsWith("toLocale")) return formatDateLocale(name, dateTime(receiver), args, options.budget, context);
           if (name.startsWith("set")) return coerceDateSetter(name, receiver, args, options.budget, context);
           const value = method.invoke(receiver, args);
           return typeof value === "string" ? options.budget.allocateString(value) : value;
         }
       })
     );
+  methods.set("toGMTString", methods.get("toUTCString"));
   methods.set(Symbol.toPrimitive, createSandboxClosure({
     guest: true,
     sandbox: true,
@@ -21978,7 +22090,7 @@ async function coerceDateSetter(name, receiver, args, budget, context) {
   const initialTime = dateTime(receiver);
   const converted = [];
   for (const value of args.slice(0, method.length)) converted.push(await sandboxNumber(value, budget, context));
-  if (Number.isNaN(initialTime) && name !== "setTime" && !name.endsWith("FullYear")) return NaN;
+  if (Number.isNaN(initialTime) && name !== "setTime" && name !== "setYear" && !name.endsWith("FullYear")) return NaN;
   const result = method.invoke(createSandboxDate(initialTime), converted);
   return dateMethods.get("setTime").invoke(receiver, [result]);
 }
@@ -40337,4 +40449,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-OK6MNHBQ.js.map
+//# sourceMappingURL=chunk-KKMT52LR.js.map