@mercuryworkshop/scramjet 2.0.1-alpha → 2.0.5-alpha

package/dist/types/Tap.d.ts

@@ -0,0 +1,32 @@
+type Description = {
+    context?: object;
+    props?: object;
+};
+type Callback<T extends Description> = (context: T["context"], props: T["props"]) => void | Promise<void>;
+type Sorter = (other: Plugin) => number;
+type CallbackInfo<T extends Description> = {
+    callback: Callback<T>;
+    plugin: Plugin;
+    sorter: Sorter;
+};
+type InternalHookDescription = {
+    tap: TapInternal;
+    key: string;
+};
+type TapInternal = {
+    callbacks: Record<string, CallbackInfo<Description>[]>;
+};
+export type TapInstance<T extends Record<string, Description>> = {
+    [K in keyof T]: T[K] & InternalHookDescription;
+};
+export declare class Plugin {
+    name: string;
+    constructor(name: string);
+    tap<T extends Description>(hook: T, callback: Callback<T>, sorter?: Sorter): void;
+}
+export declare class Tap {
+    static dispatch<T extends Description>(hook: T, context: T["context"], props: T["props"]): Promise<void[]>;
+    static tap<T extends Description>(hook: T, callback: Callback<T>, plugin: Plugin, sorter: Sorter): void;
+    static create<T extends Record<string, Description>>(): TapInstance<T>;
+}
+export {};

package/dist/types/client/client.d.ts

@@ -1,16 +1,21 @@
-type ScramjetFrame = any;
-import { BareCompatibleClient, ProxyTransport } from "@mercuryworkshop/proxy-transports";
-import { type URLMeta } from "../shared/rewriters/url";
-import { ScramjetContext } from "../shared";
+import { BareCompatibleClient, ProxyTransport, RawHeaders } from "@mercuryworkshop/proxy-transports";
+import { LifecycleHooks } from "./events";
+import { RewriteUrlOptions, type URLMeta } from "../shared/rewriters/url";
+import { HtmlRewriterHooks, ScramjetContext, ScramjetHeaders } from "../shared";
 import { SingletonBox } from "./singletonbox";
 import { ScramjetConfig } from "../types";
+import { type CookieSyncEntry, type CookieSyncOptions, TrackedHistoryState } from "../fetch";
+import { AnyFunction } from "../types";
+import { _URL } from "../shared/snapshot";
 export type ScramjetClientInit = {
     context: ScramjetContext;
     transport: ProxyTransport;
-    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    sendSetCookie: (cookies: CookieSyncEntry[], options?: CookieSyncOptions) => Promise<void>;
     shouldPassthroughWebsocket?: (url: string | URL) => boolean;
     shouldBlockMessageEvent?: (ev: MessageEvent) => boolean;
     hookSubcontext: (self: Self, frame?: HTMLIFrameElement) => ScramjetClient;
+    initHeaders: RawHeaders;
+    history: TrackedHistoryState[];
 };
 type NativeStore = {
     store: Record<string, any>;
@@ -22,40 +27,45 @@ type DescriptorStore = {
     get: (target: string, that: any) => any;
     set: (target: string, that: any, value: any) => void;
 };
-export type AnyFunction = Function;
+type Traverse<O extends Record<any, any>, P extends string> = P extends `${infer K}.${infer R}` ? Traverse<O[K], R> : O[P];
+type GlobalTraverse<P extends string> = Traverse<GlobalThis & Record<string, any>, P>;
+type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? Y : N;
+type ProxyApplyThis<T extends string> = unknown extends ThisParameterType<Extract<GlobalTraverse<T>, AnyFunction>> ? T extends `${infer ClassName}.prototype.${string}` ? GlobalTraverse<ClassName> extends {
+    prototype: infer Proto;
+} ? Proto : unknown : unknown : ThisParameterType<Extract<GlobalTraverse<T>, AnyFunction>>;
 export type ScramjetModule = {
     enabled: (client: ScramjetClient) => boolean | undefined;
-    disabled: (client: ScramjetClient, self: typeof globalThis) => void | undefined;
+    disabled: (client: ScramjetClient, self: GlobalThis) => void | undefined;
     order: number | undefined;
-    default: (client: ScramjetClient, self: typeof globalThis) => void;
+    default: (client: ScramjetClient, self: GlobalThis) => void;
 };
-export type ProxyCtx = {
-    fn: AnyFunction;
-    this: any;
-    args: any[];
-    newTarget: AnyFunction;
-    return: (r: any) => void;
-    call: () => any;
+export type ProxyCtx<T extends string = string, U extends "construct" | "apply" = "apply"> = {
+    fn: GlobalTraverse<T>;
+    this: IfEquals<U, "construct", null, ProxyApplyThis<T>>;
+    args: IfEquals<U, "construct", ConstructorParameters<GlobalTraverse<T>>, Parameters<GlobalTraverse<T>>>;
+    newTarget: IfEquals<U, "construct", GlobalTraverse<T>, null>;
+    return: (r: IfEquals<U, "construct", InstanceType<GlobalTraverse<T>>, ReturnType<GlobalTraverse<T>>>) => void;
+    call: () => IfEquals<U, "construct", InstanceType<GlobalTraverse<T>>, ReturnType<GlobalTraverse<T>>>;
 };
-export type Proxy = {
-    construct?(ctx: ProxyCtx): any;
-    apply?(ctx: ProxyCtx): any;
+export type Proxy<T extends string = string> = {
+    construct?(ctx: ProxyCtx<T, "construct">): any;
+    apply?(ctx: ProxyCtx<T, "apply">): any;
 };
-export type TrapCtx<T> = {
+export type TrapCtx<T extends string> = {
     this: any;
-    get: () => T;
-    set: (v: T) => void;
+    get: () => GlobalTraverse<T>;
+    set: (v: GlobalTraverse<T>) => void;
 };
-export type Trap<T> = {
+export type Trap<T extends string> = {
     writable?: boolean;
     value?: any;
     enumerable?: boolean;
     configurable?: boolean;
-    get?: (ctx: TrapCtx<T>) => T;
-    set?: (ctx: TrapCtx<T>, v: T) => void;
+    get?: (ctx: TrapCtx<T>) => GlobalTraverse<T>;
+    set?: (ctx: TrapCtx<T>, v: GlobalTraverse<T>) => void;
 };
 export declare class ScramjetClient {
-    global: typeof globalThis;
+    global: GlobalThis;
     init: ScramjetClientInit;
     locationProxy: any;
     serviceWorker: ServiceWorkerContainer;
@@ -73,17 +83,31 @@ export declare class ScramjetClient {
     meta: URLMeta;
     box: SingletonBox;
     context: ScramjetContext;
-    constructor(global: typeof globalThis, init: ScramjetClientInit);
-    get frame(): ScramjetFrame | null;
-    get isSubframe(): boolean;
+    initHeaders: ScramjetHeaders;
+    history: TrackedHistoryState[];
+    hooks: {
+        rewriter: {
+            html: import("../Tap").TapInstance<HtmlRewriterHooks>;
+        };
+        lifecycle: import("../Tap").TapInstance<LifecycleHooks>;
+    };
+    constructor(global: GlobalThis, init: ScramjetClientInit);
+    /** Apply document injection init when a client was already installed (e.g. early contentWindow). */
+    syncDocumentInit(init: {
+        initHeaders: RawHeaders;
+        history: TrackedHistoryState[];
+        cookies?: string;
+    }): void;
     hook(): void;
-    get url(): URL;
-    set url(url: URL | string);
-    Proxy(name: string | string[], handler: Proxy): void;
-    RawProxy(target: any, prop: string, handler: Proxy, debugname?: string): void;
-    Trap<T>(name: string | string[], descriptor: Trap<T>): PropertyDescriptor;
-    RawTrap<T>(target: any, prop: string, descriptor: Trap<T>): PropertyDescriptor;
-    rewriteUrl(url: string | URL): string;
+    get url(): _URL;
+    set url(url: _URL | string);
+    Proxy<T extends string>(name: T, handler: Proxy<T>): void;
+    Proxy<const T extends readonly string[]>(name: T, handler: Proxy<T[number]>): void;
+    RawProxy(target: any, prop: string, handler: Proxy<any>, debugname?: string): void;
+    Trap<T extends string>(name: T, handler: Trap<T>): void;
+    Trap<const T extends readonly string[]>(name: T, handler: Trap<T[number]>): void;
+    RawTrap(target: any, prop: string, descriptor: Trap<any>): void;
+    rewriteUrl(url: string | URL, options?: RewriteUrlOptions): string;
     unrewriteUrl(url: string | URL): string;
     flagEnabled(flag: keyof ScramjetConfig["flags"]): boolean;
     get config(): ScramjetConfig;

package/dist/types/client/events.d.ts

@@ -1,38 +1,10 @@
-import { ScramjetClient } from "./index";
-/**
- * Union type for all Scramjet proxified navigation events.
- */
-export type ScramjetEvent = NavigateEvent | UrlChangeEvent | ScramjetContextEvent;
-/**
- * Type map for all Scramjet navigation events with their corresponding event types.
- */
-export type ScramjetEvents = {
-    navigate: NavigateEvent;
-    urlchange: UrlChangeEvent;
-    contextInit: ScramjetContextEvent;
+export type LifecycleHooks = {
+    navigate: {
+        context: {
+            type: "location" | "history" | "hashchange";
+        };
+        props: {
+            url: string;
+        };
+    };
 };
-/**
- * Navigation event class fired when Scramjet frame navigates to a new proxified URL.
- */
-export declare class NavigateEvent extends Event {
-    url: string;
-    type: string;
-    constructor(url: string);
-}
-/**
- * URL change event class fired when the proxified URL changes in a Scramjet frame.
- */
-export declare class UrlChangeEvent extends Event {
-    url: string;
-    type: string;
-    constructor(url: string);
-}
-/**
- * Event class fired when Scramjet initializes in a frame.
- */
-export declare class ScramjetContextEvent extends Event {
-    window: Self;
-    client: ScramjetClient;
-    type: string;
-    constructor(window: Self, client: ScramjetClient);
-}

package/dist/types/client/global.d.ts

@@ -0,0 +1,4 @@
+import { ScramjetClient } from "./index";
+export declare const UNSAFE_GLOBALS: string[];
+export declare function createGlobalProxy(client: ScramjetClient, self: typeof globalThis): typeof globalThis;
+export declare function createDocumentProxy(client: ScramjetClient, self: typeof globalThis): any;

package/dist/types/client/helpers.d.ts

@@ -1 +1 @@
-export declare function getOwnPropertyDescriptorHandler(target: any, prop: any): TypedPropertyDescriptor<any>;
+export declare function getOwnPropertyDescriptorHandler(target: any, prop: any): PropertyDescriptor;

package/dist/types/client/location.d.ts

@@ -1,2 +1,2 @@
 import { ScramjetClient } from "./index";
-export declare function createLocationProxy(client: ScramjetClient, self: typeof globalThis): any;
+export declare function createLocationProxy(client: ScramjetClient, self: GlobalThis): any;

package/dist/types/client/shared/unproxy.d.ts

@@ -0,0 +1,19 @@
+import { ProxyCtx, ScramjetClient } from "../client";
+/**
+ * Maps each fast-path wrapper function back to the native function it
+ * stands in for, so `Function.prototype.toString` interception
+ * (sourcemaps.ts) can return the original native source string and avoid
+ * leaking our wrapper's body to anti-tampering checks. Module-level so
+ * it survives across module loads and is shared with sourcemaps.ts.
+ */
+export declare const NATIVE_BACKING: WeakMap<AnyFunction, AnyFunction>;
+type AnyFunction = (...args: any[]) => any;
+export declare const order = 3;
+export declare const enabled: (c: ScramjetClient) => boolean;
+export default function (client: ScramjetClient, self: typeof window): void;
+/**
+ * Legacy helper retained for backward compatibility with any consumer that
+ * imported it. New code should rely on the IDL-driven hooks installed above.
+ */
+export declare function unproxy(ctx: ProxyCtx, client: ScramjetClient): void;
+export {};

package/dist/types/client/shared/wrap.d.ts

@@ -1,4 +1,4 @@
 import { ScramjetClient } from "../index";
-export declare function createWrapFn(client: ScramjetClient, self: typeof globalThis): (identifier: any, strict: boolean) => any;
+export declare function createWrapFn(client: ScramjetClient, self: GlobalThis): (identifier: any, strict: boolean) => any;
 export declare const order = 4;
-export default function (client: ScramjetClient, self: typeof globalThis): void;
+export default function (client: ScramjetClient, self: GlobalThis): void;

package/dist/types/client/singletonbox.d.ts

@@ -1,3 +1,4 @@
+import { IncrementalHtmlRewriter } from "../shared";
 import { ScramjetClient } from "./client";
 import { SourceMaps } from "./shared/sourcemaps";
 export declare class SingletonBox {
@@ -6,6 +7,7 @@ export declare class SingletonBox {
     globals: Map<Self, ScramjetClient>;
     documents: Map<Document, ScramjetClient>;
     locations: Map<Location, ScramjetClient>;
+    writeRewriters: WeakMap<Document, IncrementalHtmlRewriter>;
     ctors: Record<string, Function[]>;
     sourcemaps: SourceMaps;
     constructor(ownerclient: ScramjetClient);

package/dist/types/client/unproxy.generated.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Single character proxy "kind" tag:
+ *   "w" -> Window/WindowProxy   "d" -> Document
+ *   "*" -> overload disagrees, probe the value at runtime
+ */
+export type ProxyKind = "w" | "d" | "*";
+/**
+ * Selector for a Window/Document value reachable from an operation argument.
+ *   [argIdx, kind]                 -- the entire argument
+ *   [argIdx, kind, ...path]        -- a property path inside a dict arg
+ *                                     (e.g. options.root)
+ */
+export type ArgSelector = readonly [
+    argIdx: number,
+    kind: "w" | "d",
+    ...path: string[]
+];
+/**
+ * Operation/constructor table entry:
+ *   [owner, member, isStatic, isCtor, argSelectors, returnKind]
+ *
+ * - owner is the interface/namespace name (e.g. "Document", "Window")
+ * - member is the method name; "" for constructors
+ * - isStatic=true patches `Owner.member`, false patches `Owner.prototype.member`
+ * - isCtor=true patches the interface constructor itself
+ * - returnKind=""  means no return wrapping needed
+ */
+export type OpEntry = readonly [
+    owner: string,
+    member: string,
+    isStatic: boolean,
+    isCtor: boolean,
+    argSelectors: readonly ArgSelector[],
+    returnKind: ProxyKind | ""
+];
+/**
+ * Attribute table entry:
+ *   [owner, member, isStatic, kind, readonly]
+ *
+ * isStatic=true patches `Owner.member`, false patches `Owner.prototype.member`.
+ */
+export type AttrEntry = readonly [
+    owner: string,
+    member: string,
+    isStatic: boolean,
+    kind: ProxyKind,
+    readonly: boolean
+];
+export declare const OPERATIONS: readonly OpEntry[];
+export declare const ATTRIBUTES: readonly AttrEntry[];

package/dist/types/fetch/body.d.ts

@@ -0,0 +1,3 @@
+import { BareResponse } from "@mercuryworkshop/proxy-transports";
+import { BodyType, ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest } from ".";
+export declare function rewriteBody(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, response: BareResponse): Promise<BodyType>;

package/dist/types/fetch/fetch.d.ts

@@ -0,0 +1,7 @@
+import { BareResponse } from "@mercuryworkshop/proxy-transports";
+import { ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest, ScramjetFetchResponse } from ".";
+import { ScramjetHeaders } from "../shared";
+export declare function doHandleFetch(handler: ScramjetFetchHandler, request: ScramjetFetchRequest): Promise<ScramjetFetchResponse>;
+export declare function doNetworkFetch(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, newheaders: ScramjetHeaders): Promise<BareResponse>;
+/** Simplified registrable-domain check used for cross-site redirect detection. */
+export declare function registrableDomainForRedirect(hostname: string): string;

package/dist/types/fetch/headers.d.ts

@@ -0,0 +1,19 @@
+import { ScramjetHeaders } from "../shared";
+import { ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest } from ".";
+import { RawHeaders } from "@mercuryworkshop/proxy-transports";
+export declare function rewriteResponseHeaders(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, rawHeaders: RawHeaders): Promise<ScramjetHeaders>;
+export declare function rewriteRequestHeaders(request: ScramjetFetchRequest, handler: ScramjetFetchHandler, parsed: ScramjetFetchParsed): ScramjetHeaders;
+/**
+ * Compute the immediate Sec-Fetch-Site relation between an initiator origin and
+ * a destination URL.
+ *
+ * - "same-origin" if scheme + host + port match exactly.
+ * - "same-site" if scheme matches and the registrable domains match.
+ * - "cross-site" otherwise.
+ */
+export declare function computeFetchSite(originUrl: URL, destUrl: URL): "same-origin" | "same-site" | "cross-site";
+/**
+ * Combine two Sec-Fetch-Site classifications, returning the "worst" (least
+ * trusted) of the two. Used when propagating state through redirect chains.
+ */
+export declare function worstFetchSite(a: "none" | "same-origin" | "same-site" | "cross-site", b: "none" | "same-origin" | "same-site" | "cross-site"): "none" | "same-origin" | "same-site" | "cross-site";

package/dist/types/fetch/index.d.ts

@@ -1,11 +1,14 @@
-import { BareCompatibleClient, BareResponse, ProxyTransport, RawHeaders, BareRequestInit } from "@mercuryworkshop/proxy-transports";
+import { BareCompatibleClient, BareResponse, ProxyTransport, BareRequestInit } from "@mercuryworkshop/proxy-transports";
 import { type URLMeta } from "../shared/rewriters/url";
+import { type ScramjetRequestMode } from "./parse";
 import { ScramjetHeaders } from "../shared/headers";
-import { ScramjetContext } from "../shared";
-import DomHandler from "domhandler";
+import { HtmlRewriterHooks, ScramjetContext } from "../shared";
+import { TapInstance } from "../Tap";
+import { _URL, _Map } from "../shared/snapshot";
 export interface ScramjetFetchRequest {
     rawUrl: URL;
-    destination: RequestDestination;
+    rawReferrer: string | null;
+    rawDestination: RequestDestination;
     mode: RequestMode;
     referrer: string;
     method: string;
@@ -13,12 +16,25 @@ export interface ScramjetFetchRequest {
     cache: RequestCache;
     initialHeaders: ScramjetHeaders;
     rawClientUrl?: URL;
+    /** The service worker FetchEvent.clientId that originated this request. */
+    clientId: string;
 }
 export interface ScramjetFetchParsed {
-    url: URL;
-    clientUrl?: URL;
+    url: _URL;
+    clientUrl?: _URL;
+    referrerSourceUrl?: _URL | null;
+    hadExtraParams: boolean;
+    crossSiteRedirect: boolean;
+    fetchSiteState?: "same-origin" | "same-site" | "cross-site";
+    fetchInitiatorOrigin?: string;
+    fetchCredentialsInclude?: boolean;
+    fetchMode?: ScramjetRequestMode;
+    isIframe?: boolean;
+    destination: RequestDestination;
     meta: URLMeta;
-    scriptType: "module" | "regular";
+    isModule: boolean;
+    referrerPolicy?: string;
+    trackedClient?: ScramjetFetchTrackedClient;
 }
 export interface ScramjetFetchResponse {
     body: BodyType;
@@ -26,55 +42,87 @@ export interface ScramjetFetchResponse {
     status: number;
     statusText: string;
 }
+export type CookieSyncEntry = {
+    url: URL;
+    cookie: string;
+};
+export type CookieSyncOptions = {
+    clear?: boolean;
+    destination?: RequestDestination;
+};
 export type FetchHandlerInit = {
     transport: ProxyTransport;
     context: ScramjetContext;
     crossOriginIsolated?: boolean;
-    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    sendSetCookie: (cookies: CookieSyncEntry[], options?: CookieSyncOptions) => Promise<void>;
     fetchDataUrl(dataUrl: string): Promise<BareResponse>;
     fetchBlobUrl(blobUrl: string): Promise<BareResponse>;
 };
+export type TrackedHistoryState = {
+    url: string;
+    refererPolicy?: string;
+};
+export declare class ScramjetFetchTrackedClient {
+    clientId: string;
+    history: TrackedHistoryState[];
+    constructor(clientId: string);
+}
 export declare class ScramjetFetchHandler extends EventTarget {
     client: BareCompatibleClient;
     crossOriginIsolated: boolean;
     context: ScramjetContext;
+    trackedClients: _Map<string, ScramjetFetchTrackedClient>;
+    hooks: {
+        rewriter: {
+            html: TapInstance<HtmlRewriterHooks>;
+        };
+        fetch: TapInstance<FetchHooks>;
+    };
     fetchDataUrl: (dataUrl: string) => Promise<Response>;
     fetchBlobUrl: (blobUrl: string) => Promise<Response>;
-    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    sendSetCookie: (cookies: CookieSyncEntry[], options?: CookieSyncOptions) => Promise<void>;
     constructor(init: FetchHandlerInit);
     handleFetch(request: ScramjetFetchRequest): Promise<ScramjetFetchResponse>;
 }
-export declare function parseRequest(request: ScramjetFetchRequest, handler: ScramjetFetchHandler): ScramjetFetchParsed;
-export declare function rewriteHeaders(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, rawHeaders: RawHeaders): Promise<ScramjetHeaders>;
-type BodyType = string | ArrayBuffer | Blob | ReadableStream<any>;
-export declare class ScramjetHTMLPreRewriteEvent extends Event {
-    handler: DomHandler;
-    context: ScramjetFetchRequest;
-    parsed: ScramjetFetchParsed;
-    constructor(handler: DomHandler, context: ScramjetFetchRequest, parsed: ScramjetFetchParsed);
-}
-export declare class ScramjetHTMLPostRewriteEvent extends Event {
-    handler: DomHandler;
-    context: ScramjetFetchRequest;
-    parsed: ScramjetFetchParsed;
-    constructor(handler: DomHandler, context: ScramjetFetchRequest, parsed: ScramjetFetchParsed);
-}
-export declare class ScramjetResponseEvent extends Event {
-    context: ScramjetFetchRequest;
-    parsed: ScramjetFetchParsed;
-    response: ScramjetFetchResponse;
-    _response?: ScramjetFetchResponse | Promise<ScramjetFetchResponse>;
-    constructor(context: ScramjetFetchRequest, parsed: ScramjetFetchParsed, response: ScramjetFetchResponse);
-    respondWith(response: ScramjetFetchResponse | Promise<ScramjetFetchResponse>): void;
-}
-export declare class ScramjetRequestEvent extends Event {
-    context: ScramjetFetchRequest;
-    url: URL;
-    parsed: ScramjetFetchParsed;
-    init: BareRequestInit;
-    client: BareCompatibleClient;
-    _response?: BareResponse | Promise<BareResponse> | Response | Promise<Response>;
-    constructor(context: ScramjetFetchRequest, url: URL, parsed: ScramjetFetchParsed, init: BareRequestInit, client: BareCompatibleClient);
-    respondWith(response: BareResponse | Promise<BareResponse>): void;
-}
-export {};
+export type FetchHooks = {
+    intercept: {
+        context: {
+            request: ScramjetFetchRequest;
+            parsed: ScramjetFetchParsed;
+        };
+        props: {
+            response?: ScramjetFetchResponse;
+        };
+    };
+    request: {
+        context: {
+            request: ScramjetFetchRequest;
+            parsed: ScramjetFetchParsed;
+            client: BareCompatibleClient;
+        };
+        props: {
+            init: BareRequestInit;
+            url: URL;
+            earlyResponse?: BareResponse;
+        };
+    };
+    preresponse: {
+        context: {
+            request: ScramjetFetchRequest;
+            parsed: ScramjetFetchParsed;
+        };
+        props: {
+            response: BareResponse;
+        };
+    };
+    response: {
+        context: {
+            request: ScramjetFetchRequest;
+            parsed: ScramjetFetchParsed;
+        };
+        props: {
+            response: ScramjetFetchResponse;
+        };
+    };
+};
+export type BodyType = string | ArrayBuffer | Blob | ReadableStream<any>;

package/dist/types/fetch/parse.d.ts

@@ -0,0 +1,22 @@
+import { ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest } from ".";
+export declare const QP: {
+    readonly referrerPolicy: "$rfp";
+    readonly referrerSource: "$rfs";
+    readonly isModule: "$module";
+    readonly topFrame: "$tf";
+    readonly parentFrame: "$pf";
+    readonly isIframe: "$iframe";
+    readonly mode: "$mode";
+    readonly credentials: "$cred";
+    readonly destination: "$dest";
+    readonly initiatorOrigin: "$io";
+    readonly fetchSite: "$fs";
+    readonly crossSiteRedirect: "$csr";
+};
+export type QueryParamKey = keyof typeof QP;
+export type QueryParams = Partial<Record<QueryParamKey, string>>;
+export declare function parseQueryParams(searchParams: URLSearchParams): {
+    params: QueryParams;
+    extras: Record<string, string>;
+};
+export declare function parseRequest(request: ScramjetFetchRequest, handler: ScramjetFetchHandler): ScramjetFetchParsed;

package/dist/types/fetch/util.d.ts

@@ -0,0 +1,7 @@
+import { ScramjetHeaders } from "../shared";
+import { BareResponse } from "@mercuryworkshop/proxy-transports";
+import { ScramjetFetchParsed } from ".";
+export declare function normalizeContentType(parsed: ScramjetFetchParsed, headers: ScramjetHeaders): void;
+export declare function isRedirect(response: BareResponse): boolean;
+export declare function isDocument(parsed: ScramjetFetchParsed): boolean;
+export declare function createReferrerString(clientUrl: URL, resource: URL, policy: string | null): string;

package/dist/types/index.d.ts

@@ -5,5 +5,7 @@ export * from "./shared";
 export * from "./symbols";
 export * from "./types";
 export * from "./fetch";
+export * from "./Tap";
+export { BareResponse } from "@mercuryworkshop/proxy-transports";
 export declare const defaultConfig: ScramjetConfig;
 export declare const defaultConfigDev: ScramjetConfig;

package/dist/types/shared/cookie.d.ts

@@ -2,17 +2,25 @@ export type Cookie = {
     name: string;
     value: string;
     path?: string;
-    expires?: string;
+    expires?: number;
     maxAge?: number;
     domain?: string;
+    hostOnly?: boolean;
     secure?: boolean;
     httpOnly?: boolean;
-    sameSite?: "strict" | "lax" | "none";
+    sameSite?: string;
 };
 export declare class CookieJar {
     private cookies;
-    setCookies(cookies: string[], url: URL): void;
-    getCookies(url: URL, fromJs: boolean): string;
-    load(cookies: string): null;
+    private byDomain;
+    private defaultPath;
+    private pathMatches;
+    private indexCookie;
+    private unindexCookie;
+    private removeById;
+    setCookies(cookieString: string, url: URL): void;
+    getCookies(url: URL, fromJs: boolean, sameSiteContext?: "strict" | "lax" | "cross-site"): string;
+    load(cookies: string | Record<string, Cookie>): void;
+    clear(): void;
     dump(): string;
 }

package/dist/types/shared/htmlRules.d.ts

@@ -1,5 +1,5 @@
 import { URLMeta } from "./rewriters/url";
-import { ScramjetContext } from "./";
+import { ScramjetContext } from "../shared";
 export declare const htmlRules: {
     [key: string]: "*" | string[] | ((...any: any[]) => string | null);
     fn: (value: string, context: ScramjetContext, meta: URLMeta) => string | null;