@redirhub/cloudflare-redirects 0.1.0 → 0.2.0

package/README.md

@@ -22,6 +22,21 @@ and this package passes its [golden sample](spec/v1). [RedirHub](https://www.red
 publishes the file for you: you manage the redirects in its dashboard, API or MCP server and see
 the redirects and 404s in its analytics.
 
+## For AI coding assistants
+
+To put this in front of a site on Cloudflare:
+
+1. `npm install @redirhub/cloudflare-redirects` in a Worker project.
+2. `export default createWorker({ settings: (env) => ({ rulesUrl: env.ACME_RULES_URL, key: env.ACME_INTEGRATION_KEY }) })`
+   as the Worker's entry; pass `origin` only if requests should go somewhere other than `fetch(request)`.
+3. In `wrangler.toml`: a route `<hostname>/*` on the zone, the rules address as a plain `[vars]`
+   value, and the integration key as a secret (`wrangler secret put ACME_INTEGRATION_KEY`). Names
+   come from the RedirHub dashboard.
+4. Check: `GET https://<hostname>/_redirhub/check` answers `token=… etag=…`, and a rule's path
+   redirects with its status. Then press **Check now** in the dashboard.
+
+Do not reimplement the rules format: this package passes the specification's golden sample.
+
 ## When to use it
 
 Cloudflare's own Redirect Rules and Bulk Redirects are managed in the Cloudflare dashboard or API.
@@ -84,12 +99,47 @@ add your own logic, pass `origin: (request, env, ctx) => …`.
 | Option | |
 | --- | --- |
 | `settings(env)` | The rules address and the key from the Worker's bindings. Empty address: off, every request goes to the origin. |
+| `report` | `false`, or `(request) => boolean`: whether to report, over the key. Default: whenever there is a key. |
 | `origin(request, env, ctx)` | Where requests no rule answers go; default `fetch(request)`. |
 | `report404` | `rules` (default): 404s of hostnames with **Report 404 pages** on; `all`: every hostname the Worker serves. |
-| `clientIp(request)` | The visitor's address; default `CF-Connecting-IP`. |
+| `hostname(request)` | The hostname to look up in the rules; `null` leaves the request alone (straight to the origin, nothing reported). Default the `Host` header. |
+| `path(request)` | The path to look up in the rules, percent-encoded; `null` leaves the request alone. Default the request URL's path. |
+| `location(location, request)` | The `Location` to send, from the one the rule gives; also the reported destination. |
+| `clientIp(request)` | The visitor's address in reports; default `CF-Connecting-IP`. `null` writes `-`. |
+| `userAgent(request)` | The User-Agent in reports; default the `User-Agent` header. `null` writes `-`. |
 | `anonymizeIp` | Report IPv4 with the last byte zeroed, IPv6 cut to /48. |
 | `logger` | Default `console`; `null` for silence. Failures are logged at most once per ten minutes. |
 
+## Customize
+
+Each option that reads the request is a function of it, so a Worker decides with ordinary code:
+
+```ts
+export default createWorker<Env>({
+  settings: (env) => ({ rulesUrl: env.ACME_RULES_URL, key: env.ACME_INTEGRATION_KEY }),
+  // Which hostname to look up in the rules. null: leave the request alone.
+  hostname: (request) => {
+    const host = new URL(request.url).hostname
+    if (host === 'api.example.com') return null // never through the rules
+    if (host.endsWith('.workers.dev')) return 'shop.example.com' // testing on workers.dev
+    return host
+  },
+  // Paths that never go through the rules.
+  path: (request) => {
+    const { pathname } = new URL(request.url)
+    return pathname.startsWith('/api/') ? null : pathname
+  },
+  // Testing on workers.dev redirects, but is not reported.
+  report: (request) => !new URL(request.url).hostname.endsWith('.workers.dev'),
+  anonymizeIp: true,
+})
+```
+
+The hostname and path these return are the ones matched, answered on the check path, appended by
+a catch-all and reported, so they always agree. Options that identify the request (`hostname`,
+`path`) leave it alone on `null`: it goes straight to the origin, and the rules are not even loaded
+for it. Options that are only reported (`clientIp`, `userAgent`) write `-` on `null`.
+
 ## Behaviour
 
 Only **GET and HEAD** on a **hostname listed** in the rules are answered; everything else goes to
@@ -108,10 +158,12 @@ Matching follows format v1: the hostname in any case, port ignored; the path cas
 percent-decoded, leading and trailing slashes ignored; scheme and query ignored. Every redirect
 carries `X-Powered-By` when the rules file has `@powered-by`.
 
-**Rules download.** The first request of an isolate downloads the file (5 second timeout) and
-waits for it; after that the copy in memory is used, and once it is older than `@refresh` seconds
-(60 by default) it is revalidated in `ctx.waitUntil` with `If-None-Match`, so no visitor waits.
-Any failure keeps the last good copy and waits 30 seconds before trying again. `@notify` (push) is
+**Rules download.** The first request of a new isolate starts the download and waits for it at
+most one second; if the rules server is slower, that request goes to the origin without rules and
+the download (5 second timeout) finishes in `ctx.waitUntil`. Requests that arrive meanwhile do not
+wait. After that the copy in memory is used, and once it is older than `@refresh` seconds (60 by
+default) it is revalidated in `ctx.waitUntil` with `If-None-Match`, so no visitor waits. Any
+failure keeps the last good copy and waits 30 seconds before trying again. `@notify` (push) is
 ignored: a Worker keeps no connection open.
 
 **Reports.** A line queued while nothing is being sent goes out at once; lines queued while a
@@ -139,7 +191,8 @@ rules file, with your key.
 
 ## Limits
 
-- The rules live in each isolate's memory: a new isolate waits for one download.
+- The rules live in each isolate's memory: a new isolate waits up to one second for them, and
+  serves no redirects until they arrive.
 - Changes are live within `@refresh` seconds per isolate (60 by default).
 - The rules file is at most 32 MB, and must fit the Worker's memory.
 
@@ -160,6 +213,14 @@ npm run check:core   # src/core and test/core are the same as redirhub/nextjs-re
 are shared, file for file, with [nextjs-redirects](https://github.com/redirhub/nextjs-redirects).
 Change both repositories together; CI flags a difference. `src/index.ts` is the Workers part.
 
+## Releasing
+
+Bump `version` in `package.json` and `VERSION` in `src/version.ts` (a test checks they match) and
+merge to `main`. The Release workflow sees a version without a tag, runs the checks, publishes to
+npm through Trusted Publishing (with provenance, no npm token stored anywhere), then tags the
+commit `v<version>` and creates the GitHub Release. Nobody pushes a tag by hand; a push without a
+version change releases nothing.
+
 ## License
 
 Apache License 2.0, see [LICENSE](LICENSE). Copyright 2026 RedirHub.

package/dist/core/redirects.d.ts

@@ -13,22 +13,60 @@ export interface RedirectsOptions {
     rulesUrl: string | null | undefined;
     /** The integration key. Without it redirects work and nothing is reported. */
     key?: string | null;
+    /**
+     * Whether to report, over the key: `false` reports nothing, a function decides per request
+     * (e.g. not for preview deployments). Default: report whenever there is a key.
+     */
+    report?: boolean | ((request: Request) => boolean);
     /**
      * Which 404 answers of the site are reported (where the site's answer is seen, `afterSite`):
      * `rules` (default) for hostnames whose `@host` line has `report404`, `all` for every hostname.
      */
     report404?: 'rules' | 'all';
-    /** The visitor's address: only a value the platform sets, never a header a client can forge. */
+    /**
+     * The hostname to look up in the rules, report and answer the check path for. Return null to
+     * leave the request alone: no rules are loaded for it and nothing is reported. Default: the
+     * `Host` header (behind `next start` the request URL names the server, not the site), else the
+     * request URL's host. Any letter case and a port are fine.
+     */
+    hostname?: (request: Request) => string | null;
+    /**
+     * The path the visitor asked for, percent-encoded as in a URL (`/caf%C3%A9`): it is matched,
+     * appended by a catch-all with `p` and reported. Return null to leave the request alone, as with
+     * `hostname`. Default: the request URL's path. Set it where the platform changed the path before
+     * your code sees it, e.g. a proxy that strips a prefix.
+     */
+    path?: (request: Request) => string | null;
+    /**
+     * The `Location` to send, from the one the rule gives (e.g. a same-site target in the visitor's
+     * language). It is also what the report names as the destination. Default: as the rule gives it.
+     */
+    location?: (location: string, request: Request) => string;
+    /**
+     * The visitor's address in reports: only a value the platform sets, never a header a client can
+     * forge. Null writes `-`.
+     */
     clientIp?: (request: Request) => string | null;
+    /** The User-Agent in reports. Default: the `User-Agent` header. Null writes `-`. */
+    userAgent?: (request: Request) => string | null;
     /** `http` or `https` as the visitor asked; default the request URL's scheme. */
     scheme?: (request: Request) => string;
     /** Report IPv4 addresses with the last byte zeroed and IPv6 addresses cut to /48. */
     anonymizeIp?: boolean;
-    fetch?: typeof fetch;
     /** Default `console`; null logs nothing. */
     logger?: Logger | null;
+}
+/**
+ * What the platform entry and the tests set, and users do not: the platform entries export a
+ * `createRedirects` that takes RedirectsOptions only.
+ */
+export interface InternalOptions extends RedirectsOptions {
+    /** Next.js passes one that sets `cache: 'no-store'`; tests pass fakes. */
+    fetch?: typeof fetch;
     /** The clock report lines are stamped with; tests fix it. */
     now?: () => Date;
+    /** How long the request that starts the first rules download waits for it; default 1000. */
+    firstWaitMs?: number;
 }
 /** What lets work outlive the response: Next's `event`, a Worker's `ctx`. */
 export interface WaitUntil {
@@ -50,6 +88,6 @@ export interface Redirects {
     /** Sends the report lines still waiting (tests, graceful shutdown). */
     flush(): Promise<void>;
 }
-export declare function createRedirects(options: RedirectsOptions): Redirects;
+export declare function createRedirects(options: InternalOptions): Redirects;
 /** IPv4 with the last byte zeroed, IPv6 cut to its first 48 bits; anything else unchanged. */
 export declare function anonymize(ip: string): string;

package/dist/core/redirects.js

@@ -15,7 +15,7 @@ const WARN_EVERY_MS = 10 * 60_000;
 export function createRedirects(options) {
     const logger = options.logger === undefined ? console : (options.logger ?? undefined);
     const rulesUrl = options.rulesUrl?.trim() ?? '';
-    const source = rulesUrl === '' ? null : new RulesSource({ url: rulesUrl, fetch: options.fetch, logger });
+    const source = rulesUrl === '' ? null : new RulesSource({ url: rulesUrl, fetch: options.fetch, firstWaitMs: options.firstWaitMs, logger });
     const key = options.key?.trim() ?? '';
     const reporter = source && key !== '' ? new Reporter({ key, hitsUrl: () => source.current?.hitsUrl ?? null, fetch: options.fetch, logger }) : null;
     const now = options.now ?? (() => new Date());
@@ -26,9 +26,24 @@ export function createRedirects(options) {
             logger?.warn(`${PACKAGE}: request passed on after an error (${error instanceof Error ? error.message : String(error)})`);
         }
     };
+    /**
+     * What the visitor asked for: the hostname as listed in the rules (lowercase, no port) and the
+     * URL with the visitor's path, or null when `hostname` or `path` leaves the request alone.
+     */
+    const visitOf = (request) => {
+        const url = new URL(request.url);
+        const hostname = options.hostname ? options.hostname(request) : (request.headers.get('host') ?? url.host);
+        const name = hostname === null ? '' : normalizeHost(hostname);
+        const path = options.path ? options.path(request) : url.pathname;
+        if (name === '' || path === null) {
+            return null;
+        }
+        url.pathname = path;
+        return { name, url };
+    };
     const keepAliveOf = (context) => (context ? (work) => context.waitUntil(work) : undefined);
     const report = (request, url, host, status, size, keepAlive, redirect) => {
-        if (!reporter) {
+        if (!reporter || options.report === false || (typeof options.report === 'function' && !options.report(request))) {
             return;
         }
         const ip = options.clientIp?.(request) ?? null;
@@ -41,12 +56,13 @@ export function createRedirects(options) {
             status,
             size,
             referer: request.headers.get('referer'),
-            userAgent: request.headers.get('user-agent'),
+            userAgent: options.userAgent ? options.userAgent(request) : request.headers.get('user-agent'),
             redirect,
         }, now()), keepAlive);
     };
     const redirect = (request, url, rules, host, rule, keepAlive) => {
-        const location = buildLocation(rule, url);
+        const target = buildLocation(rule, url);
+        const location = options.location ? options.location(target, request) : target;
         const headers = new Headers({ Location: byteString(location) });
         if (rules.poweredBy) {
             headers.set('X-Powered-By', rules.poweredBy);
@@ -59,13 +75,18 @@ export function createRedirects(options) {
             return null;
         }
         try {
+            // Before the rules: a request the integration leaves alone never waits for them.
+            const visit = visitOf(request);
+            if (visit === null) {
+                return null;
+            }
+            const { name, url } = visit;
             const keepAlive = keepAliveOf(context);
             const rules = await source.get(keepAlive);
-            const host = rules?.hosts.get(hostnameOf(request));
+            const host = rules?.hosts.get(name);
             if (!rules || !host) {
                 return null;
             }
-            const url = new URL(request.url);
             if (url.pathname === rules.checkPath) {
                 const body = `token=${host.token} etag=${rules.etag}`;
                 return new Response(request.method === 'HEAD' ? null : body, {
@@ -90,15 +111,18 @@ export function createRedirects(options) {
             if (!rules) {
                 return response;
             }
-            const name = hostnameOf(request);
+            const visit = visitOf(request);
+            if (visit === null) {
+                return response;
+            }
+            const { name, url } = visit;
             const host = rules.hosts.get(name);
             const keepAlive = keepAliveOf(context);
-            const url = new URL(request.url);
             if (host?.catchAll) {
                 await response.body?.cancel();
                 return redirect(request, url, rules, host, host.catchAll, keepAlive);
             }
-            if ((host?.report404 || options.report404 === 'all') && name !== '') {
+            if (host?.report404 || options.report404 === 'all') {
                 report(request, url, name, 404, Number(response.headers.get('content-length') ?? 0) || 0, keepAlive);
             }
             return response;
@@ -119,10 +143,6 @@ export function createRedirects(options) {
         },
     };
 }
-/** The request's hostname: the `Host` header (a self-hosted server's URL names itself), else the URL's. */
-function hostnameOf(request) {
-    return normalizeHost(request.headers.get('host') ?? new URL(request.url).host);
-}
 /** Header values carry bytes: a UTF-8 target is sent as its UTF-8 bytes, as other implementations do. */
 function byteString(value) {
     return /^[\x00-\x7f]*$/.test(value) ? value : String.fromCharCode(...new TextEncoder().encode(value));

package/dist/core/report.js

@@ -86,13 +86,15 @@ export class Reporter {
     #dropped = 0;
     #lastDropLog = Number.NEGATIVE_INFINITY;
     constructor(options) {
+        // `??` per field, not a spread: an option passed as undefined keeps its default.
         this.#options = {
+            key: options.key,
+            hitsUrl: options.hitsUrl,
             fetch: options.fetch ?? ((input, init) => fetch(input, init)),
-            timeoutMs: 2000,
-            maxQueue: 10_000,
-            budgetMs: 10_000,
-            ...options,
             logger: options.logger,
+            timeoutMs: options.timeoutMs ?? 2000,
+            maxQueue: options.maxQueue ?? 10_000,
+            budgetMs: options.budgetMs ?? 10_000,
         };
     }
     /** Queues one line; `keepAlive` holds the invocation open while this call has to send. */

package/dist/core/source.d.ts

@@ -1,9 +1,15 @@
 /**
  * Downloads the rules file and keeps the last good copy in module memory, for runtimes that keep
  * no process or connection between requests (serverless functions, Workers): no timer, no push
- * channel. The first download is awaited; after that a stale copy is answered at once and
- * refreshed in the background, so no visitor waits for it. Fails open: before the first good copy,
- * or with no rules address, there are no rules, and nothing throws.
+ * channel. Fails open: before the first good copy, or with no rules address, there are no rules,
+ * and nothing throws.
+ *
+ * No visitor waits long for a download. The request that starts a new instance's first download
+ * waits for it at most `firstWaitMs`; if it takes longer, that request goes on without rules and
+ * the download finishes in the background. Requests that arrive while a download is running do
+ * not wait at all. After the first copy, a stale copy is used at once and refreshed in the
+ * background. Only the request that starts a download keeps it alive (`keepAlive`): no request
+ * waits on another request's work.
  */
 import type { Logger } from './log.ts';
 import type { KeepAlive } from './report.ts';
@@ -16,6 +22,8 @@ export interface RulesSourceOptions {
     logger?: Logger;
     /** Per download; default 5000. */
     timeoutMs?: number;
+    /** How long the request that starts the first download waits for it; default 1000. */
+    firstWaitMs?: number;
     /** After a failed download, wait this long before the next try; default 30,000. */
     retryMs?: number;
     /** A larger file counts as a failed download; default 32 MB. */
@@ -26,6 +34,6 @@ export declare class RulesSource {
     constructor(options: RulesSourceOptions);
     /** The rules in use now, without downloading. */
     get current(): RuleSet | null;
-    /** The rules in use, downloading them when due; null until the first download succeeds. */
+    /** The rules in use, starting a download when one is due; null while there are none. */
     get(keepAlive?: KeepAlive): Promise<RuleSet | null>;
 }

package/dist/core/source.js

@@ -1,9 +1,15 @@
 /**
  * Downloads the rules file and keeps the last good copy in module memory, for runtimes that keep
  * no process or connection between requests (serverless functions, Workers): no timer, no push
- * channel. The first download is awaited; after that a stale copy is answered at once and
- * refreshed in the background, so no visitor waits for it. Fails open: before the first good copy,
- * or with no rules address, there are no rules, and nothing throws.
+ * channel. Fails open: before the first good copy, or with no rules address, there are no rules,
+ * and nothing throws.
+ *
+ * No visitor waits long for a download. The request that starts a new instance's first download
+ * waits for it at most `firstWaitMs`; if it takes longer, that request goes on without rules and
+ * the download finishes in the background. Requests that arrive while a download is running do
+ * not wait at all. After the first copy, a stale copy is used at once and refreshed in the
+ * background. Only the request that starts a download keeps it alive (`keepAlive`): no request
+ * waits on another request's work.
  */
 import { parseRules } from "./rules.js";
 import { PACKAGE, USER_AGENT } from "../version.js";
@@ -18,31 +24,38 @@ export class RulesSource {
     #inflight = null;
     #lastWarn = Number.NEGATIVE_INFINITY;
     constructor(options) {
+        // `??` per field, not a spread: an option passed as undefined keeps its default.
         this.#options = {
+            url: options.url,
             fetch: options.fetch ?? ((input, init) => fetch(input, init)),
-            timeoutMs: 5000,
-            retryMs: 30_000,
-            maxBytes: 32 << 20,
-            ...options,
             logger: options.logger,
+            timeoutMs: options.timeoutMs ?? 5000,
+            firstWaitMs: options.firstWaitMs ?? 1000,
+            retryMs: options.retryMs ?? 30_000,
+            maxBytes: options.maxBytes ?? 32 << 20,
         };
     }
     /** The rules in use now, without downloading. */
     get current() {
         return this.#rules;
     }
-    /** The rules in use, downloading them when due; null until the first download succeeds. */
+    /** The rules in use, starting a download when one is due; null while there are none. */
     async get(keepAlive) {
         const now = Date.now();
         const due = this.#rules === null || now - this.#fetchedAt >= this.#rules.refresh * 1000;
-        if (due && now >= this.#nextTry) {
-            this.#inflight ??= this.#download();
-            if (this.#rules === null) {
-                await this.#inflight;
-            }
-            else {
-                keepAlive?.(this.#inflight);
-            }
+        if (!due || now < this.#nextTry || this.#inflight !== null) {
+            return this.#rules;
+        }
+        // Cleared once settled; set first, so even a download that fails at once is cleared.
+        const download = this.#download().finally(() => {
+            this.#inflight = null;
+        });
+        this.#inflight = download;
+        keepAlive?.(download);
+        if (this.#rules === null) {
+            let timer;
+            await Promise.race([download, new Promise((resolve) => (timer = setTimeout(resolve, this.#options.firstWaitMs)))]);
+            clearTimeout(timer);
         }
         return this.#rules;
     }
@@ -84,9 +97,6 @@ export class RulesSource {
         catch (error) {
             this.#fail(error instanceof Error ? `${error.name}: ${error.message}` : 'error');
         }
-        finally {
-            this.#inflight = null;
-        }
     }
     #fail(reason) {
         const now = Date.now();

package/dist/index.d.ts

@@ -3,7 +3,9 @@
  * check path and exact rules, passes everything else to the origin, and where the origin answers
  * 404 redirects to the catch-all or reports the 404.
  */
-import { type RedirectsOptions, type WaitUntil } from './core/redirects.ts';
+import { type Redirects, type RedirectsOptions, type WaitUntil } from './core/redirects.ts';
+export type { Logger } from './core/log.ts';
+export type { Redirects, RedirectsOptions, WaitUntil };
 export interface WorkerSettings {
     rulesUrl: string | null | undefined;
     key?: string | null;
@@ -26,11 +28,8 @@ export interface WorkerOptions<Env> extends Omit<RedirectsOptions, 'rulesUrl' |
 export declare function createWorker<Env>(options: WorkerOptions<Env>): {
     fetch(request: Request, env: Env, context: WaitUntil): Promise<Response>;
 };
-/** `CF-Connecting-IP`, which Cloudflare sets. */
-export declare function cloudflareClientIp(request: Request): string | null;
-export { anonymize, createRedirects, type Redirects, type RedirectsOptions, type WaitUntil } from './core/redirects.ts';
-export type { Logger } from './core/log.ts';
-export { hitLine, type Hit, type KeepAlive, Reporter, type ReporterOptions } from './core/report.ts';
-export { buildLocation, DEFAULT_CHECK_PATH, FORMAT_MAJOR, type HostRules, matchExact, matchPath, normalizeHost, parseRules, type RedirectStatus, type Rule, type RuleSet, UnknownFormatError, } from './core/rules.ts';
-export { RulesSource, type RulesSourceOptions } from './core/source.ts';
-export { PACKAGE, USER_AGENT, VERSION } from './version.ts';
+/**
+ * The integration in two steps, for a Worker with its own routing: `handle` before the origin,
+ * `afterSite` after it, or `serve` for both. The visitor's address defaults to `CF-Connecting-IP`.
+ */
+export declare function createRedirects(options: RedirectsOptions): Redirects;

package/dist/index.js

@@ -3,7 +3,7 @@
  * check path and exact rules, passes everything else to the origin, and where the origin answers
  * 404 redirects to the catch-all or reports the 404.
  */
-import { createRedirects } from "./core/redirects.js";
+import { createRedirects as create } from "./core/redirects.js";
 /**
  * A module Worker:
  *
@@ -22,18 +22,20 @@ export function createWorker(options) {
             const { rulesUrl, key } = settings(env);
             const id = `${rulesUrl ?? ''}\0${key ?? ''}`;
             if (instance?.id !== id) {
-                instance = { id, redirects: createRedirects({ clientIp: cloudflareClientIp, ...rest, rulesUrl, key }) };
+                instance = { id, redirects: createRedirects({ ...rest, rulesUrl, key }) };
             }
             return instance.redirects.serve(request, (next) => origin(next, env, context), context);
         },
     };
 }
+/**
+ * The integration in two steps, for a Worker with its own routing: `handle` before the origin,
+ * `afterSite` after it, or `serve` for both. The visitor's address defaults to `CF-Connecting-IP`.
+ */
+export function createRedirects(options) {
+    return create({ ...options, clientIp: options.clientIp ?? cloudflareClientIp });
+}
 /** `CF-Connecting-IP`, which Cloudflare sets. */
-export function cloudflareClientIp(request) {
+function cloudflareClientIp(request) {
     return request.headers.get('cf-connecting-ip');
 }
-export { anonymize, createRedirects } from "./core/redirects.js";
-export { hitLine, Reporter } from "./core/report.js";
-export { buildLocation, DEFAULT_CHECK_PATH, FORMAT_MAJOR, matchExact, matchPath, normalizeHost, parseRules, UnknownFormatError, } from "./core/rules.js";
-export { RulesSource } from "./core/source.js";
-export { PACKAGE, USER_AGENT, VERSION } from "./version.js";

package/dist/version.d.ts

@@ -1,5 +1,5 @@
 /** This package: names its log lines and the User-Agent of rules downloads and reports. */
 export declare const PACKAGE = "cloudflare-redirects";
 /** Equal to package.json's version (a test checks it). */
-export declare const VERSION = "0.1.0";
-export declare const USER_AGENT = "cloudflare-redirects/0.1.0";
+export declare const VERSION = "0.2.0";
+export declare const USER_AGENT = "cloudflare-redirects/0.2.0";

package/dist/version.js

@@ -1,5 +1,5 @@
 /** This package: names its log lines and the User-Agent of rules downloads and reports. */
 export const PACKAGE = 'cloudflare-redirects';
 /** Equal to package.json's version (a test checks it). */
-export const VERSION = '0.1.0';
+export const VERSION = '0.2.0';
 export const USER_AGENT = `${PACKAGE}/${VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redirhub/cloudflare-redirects",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Bulk redirects and 404 monitoring for Cloudflare Workers from a remote rules file: thousands of 301/302 redirects, short links and website migrations in front of your origin, live within a minute without a redeploy. RedirHub Integration Mode.",
   "keywords": [
     "cloudflare",
@@ -59,5 +59,9 @@
   "devDependencies": {
     "@types/node": "^22.10.0",
     "typescript": "^5.9.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   }
 }