@intentic/sandbox-contract 1.341.0 → 1.343.0

package/src/text/preview-guide.ts

@@ -0,0 +1,159 @@
+import { z } from "zod";
+
+// What the daemon puts first in a workspace web page it serves for a preview (GET /workspace/preview/{ticket}/*), and
+// what that page may say to the editor framing it. The page runs as it would on a static file server, in a frame
+// sandboxed without `allow-same-origin`, so its origin is opaque: it cannot read the editor, the daemon's API or any
+// storage. This script is what keeps a page written for an ordinary origin working there, and what lets the editor
+// print it, show a Copy button over it, and say which of its files are missing:
+// - `localStorage`, `sessionStorage` and `document.cookie` throw in an opaque origin, and a page that touches them at
+//   load stops dead; each is stood in for by one held in memory for the page's life.
+// - A Vite build whose base is an absolute path preloads chunks from the server's root, outside the ticket; its
+//   `vite:preloadError` is cancelled, so the import itself, which is relative, goes ahead.
+// - `new Worker(url)` refuses any script an opaque origin did not make, which is every one; a worker is started from a
+//   script made here that loads the real one, its own relative imports and fetches resolved against where it lives.
+// - A link to another site opens in a new tab (most refuse to be framed); a link within the page's own files is
+//   followed in the frame, as a browser would.
+// - Every file it loads from beside itself is told, so the editor redraws it when one changes, and every one that
+//   fails, so the editor can name it.
+// - `intenticPrint` is answered with the page as it stands, addresses made absolute and canvases drawn as pictures.
+export const PREVIEW_GUIDE_SCRIPT = `(() => {
+    const say = (message) => parent.postMessage({ intenticHtmlPreview: message }, "*");
+    const memory = () => {
+        const held = new Map();
+        return {
+            get length() { return held.size; },
+            key: (index) => [...held.keys()][index] ?? null,
+            getItem: (key) => (held.has(String(key)) ? held.get(String(key)) : null),
+            setItem: (key, value) => { held.set(String(key), String(value)); },
+            removeItem: (key) => { held.delete(String(key)); },
+            clear: () => { held.clear(); },
+        };
+    };
+    for (const name of ["localStorage", "sessionStorage"]) {
+        try { void window[name]; } catch { Object.defineProperty(window, name, { value: memory(), configurable: true }); }
+    }
+    try { void document.cookie; } catch {
+        const jar = new Map();
+        Object.defineProperty(document, "cookie", {
+            configurable: true,
+            get: () => [...jar].map(([name, value]) => name + "=" + value).join("; "),
+            set: (text) => {
+                const [pair, ...attributes] = String(text).split(";");
+                const at = pair.indexOf("=");
+                const name = (at < 0 ? "" : pair.slice(0, at)).trim();
+                const value = (at < 0 ? pair : pair.slice(at + 1)).trim();
+                const gone = attributes.some((attribute) => {
+                    const [key, ...rest] = attribute.split("=");
+                    const setting = rest.join("=").trim();
+                    const lower = key.trim().toLowerCase();
+                    return (lower === "max-age" && Number(setting) <= 0) || (lower === "expires" && Date.parse(setting) < Date.now());
+                });
+                if (gone) jar.delete(name); else jar.set(name, value);
+            },
+        });
+    }
+    addEventListener("vite:preloadError", (event) => event.preventDefault());
+    const Native = window.Worker;
+    if (typeof Native === "function") {
+        window.Worker = function Worker(script, options) {
+            const url = new URL(String(script), location.href);
+            if (!/^https?:$/.test(url.protocol)) return new Native(script, options);
+            const at = JSON.stringify(url.href);
+            const fetches = "const get = self.fetch.bind(self); self.fetch = (input, init) => get(typeof input === 'string' ? new URL(input, " + at + ").href : input, init);";
+            // Chromium starts no module worker from a blob an opaque origin made, but does from a data address; the
+            // fetch fix is a module of its own so it runs before the worker's, as static imports run in order.
+            if (options?.type === "module") {
+                const data = (code) => "data:text/javascript," + encodeURIComponent(code);
+                return new Native(data("import " + JSON.stringify(data(fetches)) + "; import " + at + ";"), options);
+            }
+            const body = fetches + "const load = self.importScripts.bind(self);" +
+                "self.importScripts = (...urls) => load(...urls.map((each) => new URL(each, " + at + ").href)); load(" + at + ");";
+            return new Native(URL.createObjectURL(new Blob([body], { type: "text/javascript" })), options);
+        };
+        window.Worker.prototype = Native.prototype;
+    }
+    const prefix = location.pathname.split("/").slice(0, 4).join("/") + "/";
+    const own = (url) => {
+        try {
+            const parsed = new URL(url, location.href);
+            return parsed.origin === location.origin && parsed.pathname.startsWith(prefix) ? decodeURIComponent(parsed.pathname.slice(prefix.length)) : undefined;
+        // allow(silent-catch): an address that does not parse or decode is not one of the page's own files.
+        } catch { return undefined; }
+    };
+    addEventListener("click", (event) => {
+        const link = event.target instanceof Element ? event.target.closest("a[href], area[href]") : null;
+        if (link === null || event.button !== 0 || event.defaultPrevented) return;
+        const href = link.href;
+        if (!/^https?:/i.test(href) || own(href) !== undefined) return;
+        event.preventDefault();
+        say({ href });
+    });
+    const told = new Set();
+    const tell = (urls) => {
+        const fresh = [];
+        for (const url of urls) {
+            const path = own(url);
+            if (path !== undefined && !told.has(path)) { told.add(path); fresh.push(path); }
+        }
+        if (fresh.length > 0) say({ loaded: fresh });
+    };
+    tell([location.href]);
+    new PerformanceObserver((list) => tell(list.getEntries().map((entry) => entry.name))).observe({ type: "resource", buffered: true });
+    addEventListener("error", (event) => {
+        const element = event.target;
+        if (!(element instanceof Element)) return;
+        const url = element.currentSrc || element.src || element.href;
+        const path = typeof url === "string" ? own(url) : undefined;
+        if (path !== undefined) say({ missing: path });
+    }, true);
+    let moved = 0;
+    addEventListener("pointermove", (event) => {
+        if (event.pointerType === "touch" || event.timeStamp - moved < 150) return;
+        moved = event.timeStamp;
+        say({ pointer: true });
+    }, true);
+    addEventListener("pointerout", (event) => {
+        if (event.relatedTarget !== null || event.pointerType === "touch") return;
+        moved = 0;
+        say({ pointer: false });
+    }, true);
+    const snapshot = () => {
+        const live = [...document.querySelectorAll("canvas")];
+        const copy = document.documentElement.cloneNode(true);
+        [...copy.querySelectorAll("canvas")].forEach((canvas, index) => {
+            try {
+                const picture = document.createElement("img");
+                picture.src = live[index].toDataURL();
+                picture.style.cssText = canvas.style.cssText;
+                picture.width = live[index].clientWidth || live[index].width;
+                canvas.replaceWith(picture);
+            // allow(silent-catch): a canvas drawn from another origin cannot be read, and prints as the page left it.
+            } catch {}
+        });
+        for (const element of copy.querySelectorAll("[src], [href], [poster]")) {
+            for (const name of ["src", "href", "poster"]) {
+                const value = element.getAttribute(name);
+                if (value !== null && !/^(?:data|blob|javascript|mailto):/i.test(value) && URL.canParse(value, document.baseURI)) {
+                    element.setAttribute(name, new URL(value, document.baseURI).href);
+                }
+            }
+        }
+        return copy.outerHTML;
+    };
+    addEventListener("message", (event) => {
+        if (event.source === parent && event.data?.intenticPrint === true) parent.postMessage({ intenticPrintHtml: snapshot() }, "*");
+    });
+})();`;
+
+// What a served page may tell the editor, parsed where it arrives since the page's own scripts can post anything: an
+// internet address to open in a tab, whether a mouse is over it, the files it loaded from beside itself, or one that
+// failed. Paths are relative to the folder the ticket serves (WorkspacePreviewTicketSchema `root`).
+export const PreviewGuideSayingSchema = z.object({
+    intenticHtmlPreview: z.union([
+        z.object({ href: z.string().regex(/^https?:\/\//i) }),
+        z.object({ pointer: z.boolean() }),
+        z.object({ loaded: z.array(z.string()).max(1000) }),
+        z.object({ missing: z.string() }),
+    ]),
+});
+export type PreviewGuideSaying = z.infer<typeof PreviewGuideSayingSchema>["intenticHtmlPreview"];

package/src/time/zone.test.ts

@@ -1,4 +1,4 @@
-import { asCivilDay, asZone, civilDayIn, cronOptions, isZone, sameClock, utcDayOf, UTC, zoneLabel } from "./zone.js";
+import { asCivilDay, asZone, civilDayIn, cronOptions, isZone, sameClock, utcDayOf, UTC, wallClockInstant, zoneLabel } from "./zone.js";
 import type { Zone } from "./zone.js";
 
 // The distinctions this module exists to keep, each of which was a live bug before it: a cron evaluated in the
@@ -87,3 +87,20 @@ describe(`cronOptions`, () => {
         expect(cronOptions(WARSAW)).toEqual({ timezone: `Europe/Warsaw` });
     });
 });
+
+/* A time of day a program on some clock wrote ("try again at 5:46 PM") is an instant only with that clock's zone. */
+describe(`wallClockInstant`, () => {
+    test(`reads the same wall time as a different instant on each clock`, () => {
+        expect(wallClockInstant(asCivilDay(`2026-09-20`)!, 22, 43, UTC)).toBe(Date.UTC(2026, 8, 20, 22, 43));
+        expect(wallClockInstant(asCivilDay(`2026-09-20`)!, 22, 43, WARSAW)).toBe(SEPTEMBER);
+        expect(wallClockInstant(asCivilDay(`2026-12-20`)!, 15, 43, NEW_YORK)).toBe(DECEMBER);
+    });
+
+    // Warsaw changes its clocks at 01:00 UTC: on 2026-03-29 from +1 to +2, on 2026-10-25 from +2 to +1. An hour read just
+    // before the change sits on the other side of it from its naive guess, whose offset alone would be an hour out.
+    test(`takes the offset in force at the time itself, not at the naive guess, across a changeover`, () => {
+        expect(wallClockInstant(asCivilDay(`2026-03-29`)!, 1, 30, WARSAW)).toBe(Date.UTC(2026, 2, 29, 0, 30));
+        expect(wallClockInstant(asCivilDay(`2026-10-25`)!, 1, 30, WARSAW)).toBe(Date.UTC(2026, 9, 24, 23, 30));
+        expect(wallClockInstant(asCivilDay(`2026-10-25`)!, 9, 0, WARSAW)).toBe(Date.UTC(2026, 9, 25, 8, 0));
+    });
+});

package/src/time/zone.ts

@@ -115,6 +115,18 @@ export const nextDayStartIn = (at: number, zone: Zone): number => {
     return midnightUtc - offsetMinutes(midnightUtc, zone) * 60_000;
 };
 
+/**
+ * The instant a named clock reads `hours:minutes` on a calendar day: what a sentence like "try again at 5:46 PM" means,
+ * written by a program on that clock. The offset is taken again at the first answer, since across a summer-time
+ * changeover the offset at the naive guess is not the one in force at the time itself.
+ */
+export const wallClockInstant = (day: CivilDay, hours: number, minutes: number, zone: Zone): number => {
+    const [year = 0, month = 1, date = 1] = day.split("-").map(Number);
+    const naive = Date.UTC(year, month - 1, date, hours, minutes);
+    const guess = naive - offsetMinutes(naive, zone) * 60_000;
+    return naive - offsetMinutes(guess, zone) * 60_000;
+};
+
 /** Whether two zones are showing the same wall clock right now — which is when naming one on screen would be noise. */
 export const sameClock = (a: Zone, b: Zone, at: number = Date.now()): boolean => a === b || offsetMinutes(at, a) === offsetMinutes(at, b);