shabbat-gate 0.1.1 → 0.2.0

package/dist/holdingPage.js

@@ -1,38 +1,58 @@
+/** Minimal HTML-escaping for text interpolated into the page. */
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function renderSecondary(secondary) {
+    if (!secondary) {
+        return '';
+    }
+    const lines = secondary.lines.map((line) => `    <p>${escapeHtml(line)}</p>`).join('\n');
+    return `
+    <div class="secondary" dir="${secondary.dir}">
+${lines}
+    </div>`;
+}
 /** Simple, centered, mobile-responsive holding page. Inline CSS only, no external assets. */
 export function defaultRenderHoldingPage(ctx) {
-    return `<!doctype html>
-<html lang="he" dir="rtl">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<meta name="robots" content="noindex">
-<title>${ctx.siteName}</title>
-<style>
-  * { box-sizing: border-box; }
-  body {
-    margin: 0;
-    min-height: 100vh;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    font-family: system-ui, -apple-system, "Segoe UI", sans-serif;
-    background: #0f2138;
-    color: #f3efe4;
-    text-align: center;
-    padding: 24px;
-  }
-  .card { max-width: 480px; }
-  h1 { font-size: 1.5rem; margin: 0 0 12px; }
-  p { font-size: 1rem; line-height: 1.6; color: #c8a951; margin: 0 0 8px; }
-  .until { font-size: 0.9rem; color: #9fb0c4; }
-</style>
-</head>
-<body>
-  <div class="card">
-    <h1>${ctx.siteName}</h1>
-    <p>האתר סגור לכבוד ${ctx.reasonLabel}, ניפגש שוב אחרי הצאת ${ctx.reasonLabel}.</p>
-    <p class="until">שעת פתיחה משוערת: ${ctx.untilLabel}</p>
-  </div>
-</body>
+    return `<!doctype html>
+<html lang="he" dir="rtl">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex">
+<title>${escapeHtml(ctx.siteName)}</title>
+<style>
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-family: system-ui, -apple-system, "Segoe UI", sans-serif;
+    background: #0f2138;
+    color: #f3efe4;
+    text-align: center;
+    padding: 24px;
+  }
+  .card { max-width: 480px; }
+  h1 { font-size: 1.5rem; margin: 0 0 12px; }
+  p { font-size: 1rem; line-height: 1.6; color: #c8a951; margin: 0 0 8px; }
+  .until { font-size: 0.9rem; color: #9fb0c4; }
+  /* The requested two blank lines of separation before the localized block. */
+  .secondary { margin-top: 3rem; }
+  .secondary p { font-size: 0.95rem; color: #d9d2c2; }
+</style>
+</head>
+<body>
+  <div class="card">
+    <h1>${escapeHtml(ctx.siteName)}</h1>
+    <p>האתר סגור לכבוד ${escapeHtml(ctx.reasonLabel)}, ניפגש שוב אחרי צאת ${escapeHtml(ctx.closingLabel)}.</p>
+    <p class="until">שעת פתיחה משוערת: ${escapeHtml(ctx.untilLabel)}</p>${renderSecondary(ctx.secondary)}
+  </div>
+</body>
 </html>`;
 }

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 import { type HoldingPageContext } from './holdingPage.js';
-export type { Window } from './hebcal.js';
-export type { HoldingPageContext } from './holdingPage.js';
-export { isBlocked, findActiveWindow, pairWindows, fetchWindows } from './hebcal.js';
+export type { Window, FetchWindowsOptions } from './hebcal.js';
+export type { HoldingPageContext, SecondaryMessage } from './holdingPage.js';
+export type { SupportedLanguage } from './translations.js';
+export { isBlocked, findActiveWindow, mergeWindows, pairWindows, fetchWindows } from './hebcal.js';
+export { SUPPORTED_LANGUAGES, resolveVisitorLanguage } from './translations.js';
 export { isBot, BOT_PATTERN } from './botPattern.js';
 export { defaultRenderHoldingPage } from './holdingPage.js';
 export interface ShabbatGateConfig {
@@ -18,7 +20,29 @@ export interface ShabbatGateConfig {
     /** Optional custom holding-page renderer. Defaults to a Hebrew, mobile-
      *  responsive page showing siteName + when the site reopens. */
     renderHoldingPage?: (ctx: HoldingPageContext) => string;
+    /** Minutes to close the site *before* candle-lighting and reopen *after*
+     *  havdalah, on top of the raw Hebcal window. Defaults to 0 (no buffer).
+     *  Useful padding against clock drift / last-minute browsing right at the
+     *  boundary - applied at decision time, not baked into the cached windows,
+     *  so changing it takes effect immediately without waiting on the cache. */
+    bufferMinutes?: number;
+    /** When `true`, also block a visitor during Shabbat/Yom Tov in *their own*
+     *  location (derived from Cloudflare's `request.cf` geolocation), not only
+     *  during Israel's. The site is then closed to them if it's Shabbat in Israel
+     *  *or* where they are - so an overseas visitor stays blocked from Israel's
+     *  candle-lighting right through their own local havdalah. Holidays for a
+     *  visitor outside Israel use diaspora two-day Yom Tov reckoning. Defaults to
+     *  `false` (Israel-only gate, the original behavior). If geolocation is
+     *  unavailable for a request (e.g. local `wrangler dev`, or an IP Cloudflare
+     *  can't place), that request falls back to the Israel-only decision. */
+    enforceVisitorLocation?: boolean;
 }
+/** Internal cache key for the merged window list (~24h TTL via the Workers
+ *  Cache API). Exported so consumers that do their own caching of
+ *  derived/post-processed window data (e.g. after applying their own buffer)
+ *  can pick a different key and avoid accidentally colliding with this one -
+ *  which would silently serve stale, unprocessed windows for up to 24h. */
+export declare const INTERNAL_CACHE_KEY_URL = "https://internal.cache/shabbat-gate-windows-v1";
 /**
  * Returns a Cloudflare Pages Functions-compatible handler that closes the
  * site to human visitors during Shabbat and major Jewish holidays, while
@@ -27,3 +51,23 @@ export interface ShabbatGateConfig {
  * occasional missed block during an error is a minor, invisible one.
  */
 export declare function createShabbatGate(config: ShabbatGateConfig): PagesFunction;
+/**
+ * Same gate logic as `createShabbatGate`, adapted for a plain Cloudflare
+ * Worker (with a static `assets` binding) instead of Pages Functions - there
+ * is no `next()` to call in that shape, so this returns `null` for "let the
+ * real site through" and a `Response` for "serve the holding page". Wire it
+ * up in the Worker's own `fetch` handler:
+ *
+ *   const gate = createShabbatGateForWorker({ siteName: 'My Site' });
+ *   export default {
+ *     async fetch(request, env, ctx) {
+ *       const blocked = await gate(request);
+ *       return blocked ?? env.ASSETS.fetch(request);
+ *     },
+ *   };
+ *
+ * Note: a Worker with an `assets` binding skips the `fetch` handler entirely
+ * for requests matching a static asset unless `assets.run_worker_first: true`
+ * is set in `wrangler.jsonc` - without it, this gate never runs.
+ */
+export declare function createShabbatGateForWorker(config: ShabbatGateConfig): (request: Request) => Promise<Response | null>;

package/dist/index.js

@@ -1,21 +1,34 @@
 import { isBot } from './botPattern.js';
-import { fetchWindows, findActiveWindow } from './hebcal.js';
+import { fetchWindows, findActiveWindow, mergeWindows, SHABBAT_LABEL } from './hebcal.js';
 import { defaultRenderHoldingPage } from './holdingPage.js';
-export { isBlocked, findActiveWindow, pairWindows, fetchWindows } from './hebcal.js';
+import { buildSecondaryMessage, resolveVisitorLanguage } from './translations.js';
+export { isBlocked, findActiveWindow, mergeWindows, pairWindows, fetchWindows } from './hebcal.js';
+export { SUPPORTED_LANGUAGES, resolveVisitorLanguage } from './translations.js';
 export { isBot, BOT_PATTERN } from './botPattern.js';
 export { defaultRenderHoldingPage } from './holdingPage.js';
 const JERUSALEM_LATITUDE = 31.7683;
 const JERUSALEM_LONGITUDE = 35.2137;
-const CACHE_KEY_URL = 'https://internal.cache/shabbat-gate-windows-v1';
+/** Internal cache key for the merged window list (~24h TTL via the Workers
+ *  Cache API). Exported so consumers that do their own caching of
+ *  derived/post-processed window data (e.g. after applying their own buffer)
+ *  can pick a different key and avoid accidentally colliding with this one -
+ *  which would silently serve stale, unprocessed windows for up to 24h. */
+export const INTERNAL_CACHE_KEY_URL = 'https://internal.cache/shabbat-gate-windows-v1';
+/** Cache-key prefix for per-visitor-location window lists. Keyed by rounded
+ *  coordinates + timezone + reckoning so all visitors within ~1° of each other
+ *  share one cached fetch (sunset differs by only a few minutes across a cell -
+ *  immaterial at "block the whole site or not" granularity). */
+const VISITOR_CACHE_KEY_PREFIX = 'https://internal.cache/shabbat-gate-visitor-v1';
 const CACHE_TTL_SECONDS = 24 * 60 * 60;
-async function getWindows(latitude, longitude) {
+/** Fetch a window list through the Workers Cache API under a fixed key. */
+async function getCachedWindows(cacheKeyUrl, fetcher) {
     const cache = caches.default;
-    const cacheRequest = new Request(CACHE_KEY_URL);
+    const cacheRequest = new Request(cacheKeyUrl);
     const cached = await cache.match(cacheRequest);
     if (cached) {
         return (await cached.json());
     }
-    const windows = await fetchWindows(latitude, longitude);
+    const windows = await fetcher();
     const cacheResponse = new Response(JSON.stringify(windows), {
         headers: {
             'content-type': 'application/json',
@@ -25,15 +38,117 @@ async function getWindows(latitude, longitude) {
     await cache.put(cacheRequest, cacheResponse);
     return windows;
 }
-function formatJerusalemTime(epochMs) {
+/** Reads the visitor's geolocation from Cloudflare's `request.cf`. Returns
+ *  `null` when any needed field is missing/unparseable (local dev, an IP CF
+ *  can't place) so callers can fall back to the Israel-only decision. A visitor
+ *  physically in Israel gets Israel single-day reckoning; everyone else gets
+ *  diaspora two-day Yom Tov. */
+function readVisitorLocation(request) {
+    const cf = request.cf;
+    if (!cf) {
+        return null;
+    }
+    const latitude = Number(cf.latitude);
+    const longitude = Number(cf.longitude);
+    const tzid = typeof cf.timezone === 'string' ? cf.timezone : '';
+    if (!Number.isFinite(latitude) || !Number.isFinite(longitude) || !tzid) {
+        return null;
+    }
+    return { latitude, longitude, tzid, israelMode: cf.country === 'IL' };
+}
+/** Israel/Jerusalem windows - the base gate, always computed. */
+function getIsraelWindows(latitude, longitude) {
+    return getCachedWindows(INTERNAL_CACHE_KEY_URL, () => fetchWindows(latitude, longitude));
+}
+/** Windows for a specific visitor location, cached per rounded cell. */
+function getVisitorWindows(loc) {
+    const rlat = Math.round(loc.latitude);
+    const rlon = Math.round(loc.longitude);
+    const iParam = loc.israelMode ? 'on' : 'off';
+    const cacheKey = `${VISITOR_CACHE_KEY_PREFIX}?lat=${rlat}&lon=${rlon}&tz=${encodeURIComponent(loc.tzid)}&i=${iParam}`;
+    return getCachedWindows(cacheKey, () => fetchWindows(loc.latitude, loc.longitude, { israelMode: loc.israelMode, tzid: loc.tzid }));
+}
+function formatTime(epochMs, tzid) {
     return new Intl.DateTimeFormat('he-IL', {
-        timeZone: 'Asia/Jerusalem',
+        timeZone: tzid,
         day: '2-digit',
         month: '2-digit',
         hour: '2-digit',
         minute: '2-digit',
     }).format(new Date(epochMs));
 }
+function applyBuffer(windows, bufferMinutes) {
+    if (!bufferMinutes) {
+        return windows;
+    }
+    const bufferMs = bufferMinutes * 60_000;
+    return windows.map((w) => ({ ...w, start: w.start - bufferMs, end: w.end + bufferMs }));
+}
+/**
+ * Shared core: bot allowlist, bypass check, window fetch (cached) + buffer,
+ * and the fail-open try/catch. Both `createShabbatGate` (Pages Functions) and
+ * `createShabbatGateForWorker` (plain Workers + Assets) are thin wrappers
+ * around this, so neither can drift out of sync on caching/fail-open/bypass
+ * behavior.
+ */
+async function evaluateGate(config, request) {
+    const userAgent = request.headers.get('user-agent') ?? '';
+    if (isBot(userAgent)) {
+        return { type: 'pass' };
+    }
+    if (config.bypassParam && config.bypassValue) {
+        const url = new URL(request.url);
+        if (url.searchParams.get(config.bypassParam) === config.bypassValue) {
+            return { type: 'pass' };
+        }
+    }
+    try {
+        const latitude = config.latitude ?? JERUSALEM_LATITUDE;
+        const longitude = config.longitude ?? JERUSALEM_LONGITUDE;
+        const bufferMinutes = config.bufferMinutes ?? 0;
+        // Read the visitor's location once - it drives both the optional extra
+        // enforcement (their local Shabbat windows) and the localized message /
+        // local-time display shown to a visitor outside Israel.
+        const visitor = readVisitorLocation(request);
+        const isAbroad = visitor !== null && !visitor.israelMode;
+        let windows = applyBuffer(await getIsraelWindows(latitude, longitude), bufferMinutes);
+        if (config.enforceVisitorLocation && visitor) {
+            const visitorWindows = applyBuffer(await getVisitorWindows(visitor), bufferMinutes);
+            // Union of both calendars: block if it's Shabbat/Yom Tov in Israel OR
+            // where the visitor is. Merge coalesces the overlap into one continuous
+            // block so the shown reopen time is the true end of both.
+            windows = mergeWindows([...windows, ...visitorWindows]);
+        }
+        const active = findActiveWindow(windows, Date.now());
+        if (!active) {
+            return { type: 'pass' };
+        }
+        // For a visitor abroad, show times in their own timezone (that's who is
+        // looking at the page) and append a message in their browser language.
+        const displayTzid = isAbroad ? visitor.tzid : 'Asia/Jerusalem';
+        const untilLabel = formatTime(active.end, displayTzid);
+        let secondary;
+        if (isAbroad) {
+            const language = resolveVisitorLanguage(request.headers.get('accept-language') ?? '');
+            if (language !== 'he') {
+                secondary = buildSecondaryMessage(language, active.label === SHABBAT_LABEL, untilLabel);
+            }
+        }
+        const render = config.renderHoldingPage ?? defaultRenderHoldingPage;
+        const html = render({
+            siteName: config.siteName,
+            reasonLabel: active.label,
+            closingLabel: active.closingLabel,
+            untilLabel,
+            secondary,
+        });
+        return { type: 'block', html };
+    }
+    catch (error) {
+        console.error('shabbat-gate: failing open due to error', error);
+        return { type: 'pass' };
+    }
+}
 /**
  * Returns a Cloudflare Pages Functions-compatible handler that closes the
  * site to human visitors during Shabbat and major Jewish holidays, while
@@ -43,39 +158,44 @@ function formatJerusalemTime(epochMs) {
  */
 export function createShabbatGate(config) {
     return async (context) => {
-        const { request, next } = context;
-        const userAgent = request.headers.get('user-agent') ?? '';
-        if (isBot(userAgent)) {
-            return next();
-        }
-        if (config.bypassParam && config.bypassValue) {
-            const url = new URL(request.url);
-            if (url.searchParams.get(config.bypassParam) === config.bypassValue) {
-                return next();
-            }
+        const decision = await evaluateGate(config, context.request);
+        if (decision.type === 'pass') {
+            return context.next();
         }
-        try {
-            const latitude = config.latitude ?? JERUSALEM_LATITUDE;
-            const longitude = config.longitude ?? JERUSALEM_LONGITUDE;
-            const windows = await getWindows(latitude, longitude);
-            const active = findActiveWindow(windows, Date.now());
-            if (!active) {
-                return next();
-            }
-            const render = config.renderHoldingPage ?? defaultRenderHoldingPage;
-            const html = render({
-                siteName: config.siteName,
-                reasonLabel: active.label,
-                untilLabel: formatJerusalemTime(active.end),
-            });
-            return new Response(html, {
-                status: 200,
-                headers: { 'content-type': 'text/html; charset=utf-8' },
-            });
-        }
-        catch (error) {
-            console.error('shabbat-gate: failing open due to error', error);
-            return next();
+        return new Response(decision.html, {
+            status: 200,
+            headers: { 'content-type': 'text/html; charset=utf-8' },
+        });
+    };
+}
+/**
+ * Same gate logic as `createShabbatGate`, adapted for a plain Cloudflare
+ * Worker (with a static `assets` binding) instead of Pages Functions - there
+ * is no `next()` to call in that shape, so this returns `null` for "let the
+ * real site through" and a `Response` for "serve the holding page". Wire it
+ * up in the Worker's own `fetch` handler:
+ *
+ *   const gate = createShabbatGateForWorker({ siteName: 'My Site' });
+ *   export default {
+ *     async fetch(request, env, ctx) {
+ *       const blocked = await gate(request);
+ *       return blocked ?? env.ASSETS.fetch(request);
+ *     },
+ *   };
+ *
+ * Note: a Worker with an `assets` binding skips the `fetch` handler entirely
+ * for requests matching a static asset unless `assets.run_worker_first: true`
+ * is set in `wrangler.jsonc` - without it, this gate never runs.
+ */
+export function createShabbatGateForWorker(config) {
+    return async (request) => {
+        const decision = await evaluateGate(config, request);
+        if (decision.type === 'pass') {
+            return null;
         }
+        return new Response(decision.html, {
+            status: 200,
+            headers: { 'content-type': 'text/html; charset=utf-8' },
+        });
     };
 }

package/dist/translations.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Localized secondary holding-page messages, shown *below* the Hebrew message
+ * to a visitor physically outside Israel, in their own browser language.
+ *
+ * Deliberately generic: each pack only distinguishes "Shabbat" from "a Jewish
+ * holiday" and states the approximate reopen time - it never tries to name the
+ * specific holiday (Shmini Atzeret, Shavuot, ...), since reliably translating
+ * every occasion name into every language is out of scope. The exact occasion
+ * name stays on the Hebrew line only.
+ */
+export type SupportedLanguage = 'en' | 'fr' | 'ru' | 'es' | 'de' | 'ar';
+export declare const SUPPORTED_LANGUAGES: readonly SupportedLanguage[];
+/**
+ * Picks the visitor's display language from an `Accept-Language` header value.
+ * Walks the header's tags in the browser's stated order and returns the first
+ * one we have a pack for. Returns `'he'` (a signal to skip the second block
+ * entirely) if Hebrew is the visitor's top preference - they already read the
+ * Hebrew message, a translated copy would be redundant. Falls back to `'en'`
+ * when nothing matches.
+ */
+export declare function resolveVisitorLanguage(acceptLanguage: string): SupportedLanguage | 'he';
+export interface SecondaryMessage {
+    /** Text direction for the localized block (all current packs are `ltr`). */
+    dir: 'ltr' | 'rtl';
+    /** Localized lines to render, in order: [closed-reason, reopen-time]. */
+    lines: string[];
+}
+/** Builds the localized two-line block for a given language + occasion. */
+export declare function buildSecondaryMessage(language: SupportedLanguage, isShabbat: boolean, untilTime: string): SecondaryMessage;

package/dist/translations.js

@@ -0,0 +1,81 @@
+/**
+ * Localized secondary holding-page messages, shown *below* the Hebrew message
+ * to a visitor physically outside Israel, in their own browser language.
+ *
+ * Deliberately generic: each pack only distinguishes "Shabbat" from "a Jewish
+ * holiday" and states the approximate reopen time - it never tries to name the
+ * specific holiday (Shmini Atzeret, Shavuot, ...), since reliably translating
+ * every occasion name into every language is out of scope. The exact occasion
+ * name stays on the Hebrew line only.
+ */
+export const SUPPORTED_LANGUAGES = ['en', 'fr', 'ru', 'es', 'de', 'ar'];
+const PACKS = {
+    en: {
+        dir: 'ltr',
+        shabbat: 'This site is closed in observance of Shabbat.',
+        holiday: 'This site is closed in observance of a Jewish holiday.',
+        until: (time) => `We'll be back after nightfall, around ${time}.`,
+    },
+    fr: {
+        dir: 'ltr',
+        shabbat: 'Ce site est fermé en observance du Chabbat.',
+        holiday: 'Ce site est fermé en observance d’une fête juive.',
+        until: (time) => `Nous serons de retour après la tombée de la nuit, vers ${time}.`,
+    },
+    ru: {
+        dir: 'ltr',
+        shabbat: 'Этот сайт закрыт в честь субботы (Шаббата).',
+        holiday: 'Этот сайт закрыт в честь еврейского праздника.',
+        until: (time) => `Мы вернёмся после наступления темноты, примерно в ${time}.`,
+    },
+    es: {
+        dir: 'ltr',
+        shabbat: 'Este sitio está cerrado en observancia del Shabat.',
+        holiday: 'Este sitio está cerrado en observancia de una festividad judía.',
+        until: (time) => `Volveremos después del anochecer, alrededor de las ${time}.`,
+    },
+    de: {
+        dir: 'ltr',
+        shabbat: 'Diese Website ist zu Ehren des Schabbat geschlossen.',
+        holiday: 'Diese Website ist zu Ehren eines jüdischen Feiertags geschlossen.',
+        until: (time) => `Wir sind nach Einbruch der Nacht wieder da, gegen ${time}.`,
+    },
+    ar: {
+        dir: 'rtl',
+        shabbat: 'هذا الموقع مغلق احترامًا ليوم السبت (شابات).',
+        holiday: 'هذا الموقع مغلق احترامًا لعيد يهودي.',
+        until: (time) => `سنعود بعد حلول الظلام، حوالي ${time}.`,
+    },
+};
+/**
+ * Picks the visitor's display language from an `Accept-Language` header value.
+ * Walks the header's tags in the browser's stated order and returns the first
+ * one we have a pack for. Returns `'he'` (a signal to skip the second block
+ * entirely) if Hebrew is the visitor's top preference - they already read the
+ * Hebrew message, a translated copy would be redundant. Falls back to `'en'`
+ * when nothing matches.
+ */
+export function resolveVisitorLanguage(acceptLanguage) {
+    const tags = acceptLanguage
+        .split(',')
+        .map((part) => part.trim().split(';')[0].toLowerCase())
+        .filter(Boolean);
+    for (const tag of tags) {
+        const primary = tag.split('-')[0];
+        if (primary === 'he' || primary === 'iw') {
+            return 'he';
+        }
+        if (SUPPORTED_LANGUAGES.includes(primary)) {
+            return primary;
+        }
+    }
+    return 'en';
+}
+/** Builds the localized two-line block for a given language + occasion. */
+export function buildSecondaryMessage(language, isShabbat, untilTime) {
+    const pack = PACKS[language];
+    return {
+        dir: pack.dir,
+        lines: [isShabbat ? pack.shabbat : pack.holiday, pack.until(untilTime)],
+    };
+}

package/package.json

@@ -1,35 +1,36 @@
-{
-  "name": "shabbat-gate",
-  "version": "0.1.1",
-  "description": "Cloudflare Pages/Workers middleware that closes a site to human visitors during Shabbat and major Jewish holidays (Israel-observance rules), while always letting search engines and AI crawlers through.",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md",
-    "README.he.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run"
-  },
-  "keywords": [
-    "cloudflare-pages",
-    "cloudflare-workers",
-    "shabbat",
-    "jewish-holidays",
-    "hebcal",
-    "israel"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">=18"
-  },
-  "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250204.0",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.5"
-  }
-}
+{
+  "name": "shabbat-gate",
+  "version": "0.2.0",
+  "description": "Cloudflare Pages/Workers middleware that closes a site to human visitors during Shabbat and major Jewish holidays (Israel-observance rules), while always letting search engines and AI crawlers through.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "README.he.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "cloudflare-pages",
+    "cloudflare-workers",
+    "shabbat",
+    "jewish-holidays",
+    "hebcal",
+    "israel"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250204.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
+  }
+}