@speedkit/cli 4.25.2 → 4.27.0

package/dist/services/query-builder/rules/match-pattern.d.ts

@@ -0,0 +1,51 @@
+import { NormalizedRule } from "./rule-model.js";
+/**
+ * An ad-hoc narrowing of a query, given on the command line as a regular
+ * expression over the path.
+ *
+ * It is compiled into the same shape a config rule has, so everything that
+ * follows — the check against the config, the translation to SQL, the
+ * warnings about constructs Athena reads differently — is the code that
+ * already runs for the config's own rules, and the pattern cannot come to
+ * mean something else here than it would in a config.
+ *
+ * The imports here are deliberately kept to the leaves of the rule layer: the
+ * flag definitions load this module, and pulling the automata library into
+ * every `sk` invocation to validate a pattern would be a poor trade.
+ */
+/** Where a `--match` pattern shows up in reports and errors. */
+export declare const MATCH_SOURCE = "--match";
+/**
+ * Compiles one `--match` value into a regular expression.
+ *
+ * Athena carries flags inside the pattern and JavaScript carries them beside
+ * it. The operator writes the Athena form, so a leading `(?i)` is lifted into
+ * real flags here — `new RegExp('(?i)…')` would throw — and `toAthenaRegex`
+ * puts it back when the pattern is emitted.
+ *
+ * @throws SyntaxError when the value is not a regular expression.
+ */
+export declare function parseMatchPattern(value: string): RegExp;
+/**
+ * The `--match` patterns as a rule: one condition on the pathname, its
+ * entries OR'd, so `--match a --match b` keeps the pages matching either.
+ */
+export declare function buildMatchRule(values: readonly string[] | undefined): NormalizedRule | undefined;
+/**
+ * An excluding rule restated over `path + search`, so that it can be held
+ * against a `--match` pattern — or `undefined` when it cannot be restated
+ * exactly.
+ *
+ * A version 2 `pathname` condition is matched against the path alone, a
+ * version 1 one against the path with its query string, and the reduction
+ * never compares patterns across those two subjects. Since a `--match`
+ * pattern is a version 1 condition, a version 2 rule has to be said again in
+ * that subject before the two can be compared at all.
+ *
+ * This one is used to prove that a pattern is **entirely excluded**, so the
+ * safe direction is the opposite of the usual: a rule restated wider than it
+ * is would refuse a pattern that does have pages. Anything that cannot be
+ * restated exactly is therefore left out of the comparison altogether, and
+ * missing an exclusion only costs the early break.
+ */
+export declare function asPathWithSearchRule(rule: NormalizedRule): NormalizedRule | undefined;

package/dist/services/query-builder/rules/match-pattern.js

@@ -0,0 +1,141 @@
+import { escapeRegexLiteral } from "../sql/regex.js";
+import { matchesExactly, } from "./rule-model.js";
+/**
+ * An ad-hoc narrowing of a query, given on the command line as a regular
+ * expression over the path.
+ *
+ * It is compiled into the same shape a config rule has, so everything that
+ * follows — the check against the config, the translation to SQL, the
+ * warnings about constructs Athena reads differently — is the code that
+ * already runs for the config's own rules, and the pattern cannot come to
+ * mean something else here than it would in a config.
+ *
+ * The imports here are deliberately kept to the leaves of the rule layer: the
+ * flag definitions load this module, and pulling the automata library into
+ * every `sk` invocation to validate a pattern would be a poor trade.
+ */
+/** Where a `--match` pattern shows up in reports and errors. */
+export const MATCH_SOURCE = "--match";
+/**
+ * A `--match` pattern is a version 1 `pathname` condition, whatever version
+ * the config runs under: version 1 matches a pathname against the path *and*
+ * the query string, which is the subject an operator narrowing a list wants —
+ * `^/p/` anchors at the start of the path and `[?&]size=` reaches a
+ * parameter.
+ */
+const MATCH_RULE_SET_VERSION = 1;
+/** Inline flags, the way Athena takes them: `(?i)`, `(?is)`, … */
+const INLINE_FLAGS = /^\(\?([ims]+)\)/;
+/**
+ * Compiles one `--match` value into a regular expression.
+ *
+ * Athena carries flags inside the pattern and JavaScript carries them beside
+ * it. The operator writes the Athena form, so a leading `(?i)` is lifted into
+ * real flags here — `new RegExp('(?i)…')` would throw — and `toAthenaRegex`
+ * puts it back when the pattern is emitted.
+ *
+ * @throws SyntaxError when the value is not a regular expression.
+ */
+export function parseMatchPattern(value) {
+    const inline = INLINE_FLAGS.exec(value);
+    return inline
+        ? new RegExp(value.slice(inline[0].length), inline[1])
+        : new RegExp(value);
+}
+/**
+ * The `--match` patterns as a rule: one condition on the pathname, its
+ * entries OR'd, so `--match a --match b` keeps the pages matching either.
+ */
+export function buildMatchRule(values) {
+    if (!values || values.length === 0) {
+        return undefined;
+    }
+    const patterns = values.map((value) => ({
+        kind: "regexp",
+        value: parseMatchPattern(value),
+    }));
+    const condition = { patterns, subject: "pathname" };
+    return {
+        conditions: [condition],
+        criteriaOutsideTheUrl: [],
+        matchesNothing: false,
+        ruleSetVersion: MATCH_RULE_SET_VERSION,
+        source: MATCH_SOURCE,
+    };
+}
+/**
+ * An excluding rule restated over `path + search`, so that it can be held
+ * against a `--match` pattern — or `undefined` when it cannot be restated
+ * exactly.
+ *
+ * A version 2 `pathname` condition is matched against the path alone, a
+ * version 1 one against the path with its query string, and the reduction
+ * never compares patterns across those two subjects. Since a `--match`
+ * pattern is a version 1 condition, a version 2 rule has to be said again in
+ * that subject before the two can be compared at all.
+ *
+ * This one is used to prove that a pattern is **entirely excluded**, so the
+ * safe direction is the opposite of the usual: a rule restated wider than it
+ * is would refuse a pattern that does have pages. Anything that cannot be
+ * restated exactly is therefore left out of the comparison altogether, and
+ * missing an exclusion only costs the early break.
+ */
+export function asPathWithSearchRule(rule) {
+    // A version 1 rule already matches the subject the pattern is written for.
+    if (!matchesExactly(rule.ruleSetVersion)) {
+        return rule;
+    }
+    const conditions = [];
+    for (const condition of rule.conditions) {
+        // A rule constraining anything but the path cannot cover the pattern in
+        // the first place — the reduction checks that before it builds automata.
+        if (condition.subject !== "pathname") {
+            return undefined;
+        }
+        const patterns = [];
+        for (const pattern of condition.patterns) {
+            const restated = withSearch(pattern);
+            if (!restated) {
+                return undefined;
+            }
+            patterns.push(restated);
+        }
+        conditions.push({ patterns, subject: "pathname" });
+    }
+    return { ...rule, conditions, ruleSetVersion: MATCH_RULE_SET_VERSION };
+}
+/** What may follow the path in `path + search`. */
+const SEARCH = String.raw `(?:\?[\s\S]*)?`;
+/** Anything but a single `$` at the very end. */
+const INNER_END_ANCHOR = /(?<!\\)\$(?!$)/;
+/**
+ * One entry of a version 2 path condition, said over `path + search`.
+ *
+ * Only the shapes whose meaning is unchanged by the query string are
+ * restated. A pattern anchored at the start says the same thing about both
+ * subjects; where it ends at the end of the path, the query string is spelled
+ * out instead. An unanchored pattern does not survive: it would match inside
+ * a query string the path never contained.
+ */
+function withSearch(pattern) {
+    if (pattern.kind === "string") {
+        // A version 2 string is the whole path, compared case-insensitively.
+        const value = escapeRegexLiteral(pattern.value);
+        return { kind: "regexp", value: new RegExp(`^${value}${SEARCH}$`, "i") };
+    }
+    const { flags, source } = pattern.value;
+    // An alternation may hide an anchor in a branch, which the reasoning below
+    // does not see.
+    if (!source.startsWith("^") || source.includes("|")) {
+        return undefined;
+    }
+    if (INNER_END_ANCHOR.test(source)) {
+        return undefined;
+    }
+    return {
+        kind: "regexp",
+        value: /(?<!\\)\$$/.test(source)
+            ? new RegExp(`${source.slice(0, -1)}${SEARCH}$`, flags)
+            : pattern.value,
+    };
+}

package/dist/services/query-builder/rules/pattern-language.d.ts

@@ -0,0 +1,59 @@
+import { DFA, NFA } from "refa";
+import { RuleCondition } from "./rule-model.js";
+/**
+ * The set of subjects a condition accepts, as a finite automaton.
+ *
+ * Deciding whether one rule makes another redundant means deciding whether one
+ * pattern's language contains or avoids another's — a question about regular
+ * languages, not about strings, so it is answered with automata rather than
+ * guessed. `refa` builds them from the very same JavaScript patterns the config
+ * uses.
+ */
+export type ConditionLanguage = NFA;
+/**
+ * Which side of the true language an automaton is allowed to fall on.
+ *
+ * Automata cannot express an assertion — a word boundary, or the `$` inside
+ * `/^\/shop(\/|$)/` — so a pattern using one is approximated. Approximating in
+ * an arbitrary direction would let the reducer drop a rule that does matter,
+ * so each question is asked with the bound that makes its answer sound:
+ *
+ * - `atLeast` accepts everything the pattern accepts, and possibly more. Two
+ *   of these sharing nothing proves the patterns share nothing.
+ * - `atMost` accepts only what the pattern accepts, and possibly less. An
+ *   `atLeast` language inside an `atMost` one proves containment.
+ *
+ * A pattern without assertions has one exact language, and both bounds are it.
+ */
+export type LanguageBound = "atLeast" | "atMost";
+/**
+ * The language of one condition — the union of its entries, since one matching
+ * entry satisfies the condition.
+ *
+ * Returns `undefined` when an entry has no automaton at all, and the caller
+ * then leaves the rule out of every reduction.
+ */
+export declare function conditionLanguage(condition: RuleCondition, ruleSetVersion: number, bound: LanguageBound): ConditionLanguage | undefined;
+/**
+ * Everything a language does *not* accept.
+ *
+ * Determinising a language to complement it is the expensive step of the whole
+ * reduction, and one rule is compared with many others, so a caller that asks
+ * repeatedly should build this once and reuse it.
+ */
+export type LanguageOutside = DFA;
+/** The complement of an `atMost` language. */
+export declare function outsideOf(language: ConditionLanguage): LanguageOutside | undefined;
+/**
+ * True when the language stays inside the one `outside` was built from —
+ * `language ⊆ superset ⟺ language ∩ ¬superset = ∅`.
+ *
+ * @param language - has to be an `atLeast` language.
+ * @param outside - has to come from {@link outsideOf} on an `atMost` language.
+ */
+export declare function isInside(language: ConditionLanguage, outside: LanguageOutside): boolean | undefined;
+/**
+ * True when no subject is accepted by both languages. Both have to be
+ * `atLeast` languages.
+ */
+export declare function languagesDisjoint(left: ConditionLanguage, right: ConditionLanguage): boolean | undefined;

package/dist/services/query-builder/rules/pattern-language.js

@@ -0,0 +1,159 @@
+import { DFA, isDisjointWith, JS, NFA } from "refa";
+import { escapeRegexLiteral } from "../sql/index.js";
+import { matchesExactly, } from "./rule-model.js";
+/**
+ * The language of one condition — the union of its entries, since one matching
+ * entry satisfies the condition.
+ *
+ * Returns `undefined` when an entry has no automaton at all, and the caller
+ * then leaves the rule out of every reduction.
+ */
+export function conditionLanguage(condition, ruleSetVersion, bound) {
+    // The reducer asks the same condition the same question many times over,
+    // once per rule or entry it is compared with, and building an automaton is
+    // the expensive part. Callers only ever read the result.
+    const cacheKey = `${ruleSetVersion}:${bound}`;
+    const cached = cache.get(condition);
+    if (cached?.has(cacheKey)) {
+        return cached.get(cacheKey);
+    }
+    const language = buildConditionLanguage(condition, ruleSetVersion, bound);
+    if (cached) {
+        cached.set(cacheKey, language);
+    }
+    else {
+        cache.set(condition, new Map([[cacheKey, language]]));
+    }
+    return language;
+}
+/** Automata already built, per condition. Never handed out for mutation. */
+const cache = new WeakMap();
+function buildConditionLanguage(condition, ruleSetVersion, bound) {
+    let language;
+    for (const pattern of condition.patterns) {
+        const entry = patternLanguage(pattern, ruleSetVersion, bound);
+        if (!entry) {
+            return undefined;
+        }
+        if (!language) {
+            language = entry;
+            continue;
+        }
+        // Automata built for different character ranges cannot be combined; that
+        // happens when one pattern is unicode-aware and another is not.
+        if (language.maxCharacter !== entry.maxCharacter) {
+            return undefined;
+        }
+        const united = attempt(() => {
+            language?.union(entry);
+            return true;
+        });
+        if (!united) {
+            return undefined;
+        }
+    }
+    // The union of many patterns is where determinisation gets expensive, and
+    // its size is what decides that cost — so the same cap applies to it.
+    return language && language.countNodes() > MAX_NODES ? undefined : language;
+}
+/** The complement of an `atMost` language. */
+export function outsideOf(language) {
+    return attempt(() => {
+        const complement = DFA.fromFA(language);
+        complement.complement();
+        return complement;
+    });
+}
+/**
+ * True when the language stays inside the one `outside` was built from —
+ * `language ⊆ superset ⟺ language ∩ ¬superset = ∅`.
+ *
+ * @param language - has to be an `atLeast` language.
+ * @param outside - has to come from {@link outsideOf} on an `atMost` language.
+ */
+export function isInside(language, outside) {
+    if (language.maxCharacter !== outside.maxCharacter) {
+        return undefined;
+    }
+    return attempt(() => isDisjointWith(language, outside));
+}
+/**
+ * True when no subject is accepted by both languages. Both have to be
+ * `atLeast` languages.
+ */
+export function languagesDisjoint(left, right) {
+    if (left.maxCharacter !== right.maxCharacter) {
+        return undefined;
+    }
+    return attempt(() => isDisjointWith(left, right));
+}
+/**
+ * The language of a single condition entry.
+ *
+ * The automaton describes *whole* subjects, so where the pattern is not
+ * anchored it is padded: an unanchored JavaScript pattern matches anywhere in
+ * the subject, and a version 1 string is a prefix of it.
+ */
+function patternLanguage(pattern, ruleSetVersion, bound) {
+    if (pattern.kind === "string") {
+        const value = escapeRegexLiteral(pattern.value);
+        const source = matchesExactly(ruleSetVersion) ? value : `${value}${ANY}`;
+        // A string condition lower-cases both sides, which the `i` flag mirrors.
+        return build(source, "i", bound);
+    }
+    const { flags, source } = pattern.value;
+    const anchoredStart = source.startsWith("^");
+    const anchoredEnd = /(?<!\\)\$$/.test(source);
+    const inner = source.slice(anchoredStart ? 1 : 0, anchoredEnd ? -1 : undefined);
+    return build(`${anchoredStart ? "" : ANY}(?:${inner})${anchoredEnd ? "" : ANY}`, 
+    // A global or sticky flag says nothing about the language.
+    flags.replaceAll(/[gy]/g, ""), bound);
+}
+/** Matches any subject, used to pad an unanchored pattern. */
+const ANY = String.raw `[\s\S]*`;
+/**
+ * The most states an automaton may have to take part in a reduction.
+ *
+ * Comparing two automata costs far more than building them, and past a certain
+ * size that cost falls off a cliff. Measured over the configs in the
+ * onboarding repo: at 200 the slowest customer builds its query in 1.0s, at
+ * 250 the same customer takes 9.7s, and none of them reduces any better for
+ * it. The largest condition that ever carried a reduction has 189 states,
+ * which is what this leaves room for.
+ *
+ * Refusing an automaton only costs a reduction — the rule stays in the query,
+ * and the query stays correct — so the cap is safe to tighten and expensive to
+ * raise.
+ */
+const MAX_NODES = 200;
+function build(source, flags, bound) {
+    return attempt(() => {
+        const { expression, maxCharacter } = JS.Parser.fromLiteral({
+            flags,
+            source,
+        }).parse({
+            // An assertion left inside the pattern is widened or narrowed, whichever
+            // keeps the caller's answer sound.
+            assertions: bound === "atLeast" ? "ignore" : "disable",
+            backreferences: "throw",
+        });
+        const nfa = NFA.fromRegex(expression, { maxCharacter });
+        return nfa.countNodes() > MAX_NODES ? undefined : nfa;
+    });
+}
+/**
+ * Runs an automaton operation, or gives up on it.
+ *
+ * Every step can fail on a pattern that is legal but too much for an
+ * automaton — a back reference, or a determinisation that would need more
+ * states than `refa` allows. Failing means "undecidable", which costs a
+ * reduction and never a correct query.
+ */
+function attempt(operation) {
+    try {
+        return operation();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/services/query-builder/rules/rule-model.d.ts

@@ -0,0 +1,107 @@
+import { ConditionKey } from "@speedkit/rules";
+/**
+ * The rule shapes of a Speed Kit config, normalized into something the query
+ * builder can reason about.
+ *
+ * A `SpeedKitRule` in a config is loose: a condition may be a string, a
+ * regular expression or an array of both, a rule may carry criteria that have
+ * nothing to do with the URL, and the rule-set version decides what a string
+ * even means. Everything downstream — relevance, reduction, translation —
+ * works on the types here instead of on the raw config.
+ */
+/** The rule-set version a config runs under when it declares none. */
+export declare const DEFAULT_RULE_SET_VERSION = 1;
+/** Content types a page impression can have. */
+export declare const DOCUMENT_CONTENT_TYPES: readonly ["document", "navigate"];
+/** The condition keys naming a part of the URL a query can match on. */
+export declare const URL_CONDITION_KEYS: readonly [ConditionKey.Host, ConditionKey.Pathname, ConditionKey.Url];
+/**
+ * Criteria of a `SpeedKitRule` that a page impression does not carry, so they
+ * cannot be part of a query. A rule using one of these is either approximated
+ * (when it also has URL conditions) or reported as untranslatable.
+ *
+ * `hashparam` is among them: the runtime matches it against the fragment,
+ * which is not part of a URL the way the warehouse stores it.
+ */
+export declare const CRITERIA_OUTSIDE_THE_URL: ConditionKey[];
+/** The parts of a URL a rule can match on. */
+export type RuleSubject = "host" | "pathname" | "url";
+/** One entry of a rule condition. Entries of a condition are OR'd. */
+export type ConditionPattern = {
+    readonly kind: "regexp";
+    readonly value: RegExp;
+} | {
+    readonly kind: "string";
+    readonly value: string;
+};
+export interface RuleCondition {
+    /** OR'd — one matching entry satisfies the condition. */
+    readonly patterns: readonly ConditionPattern[];
+    readonly subject: RuleSubject;
+}
+export interface NormalizedRule {
+    /** AND'd — every condition of a rule has to match. */
+    readonly conditions: readonly RuleCondition[];
+    /**
+     * True when the rule can never match, whatever the URL.
+     *
+     * The runtime builds one condition per key it knows and requires all of
+     * them, so two shapes match nothing: a rule with no such key at all, and a
+     * rule whose condition is an empty list. The second one is easy to write by
+     * accident — `host: hasWebPSupport ? [] : [...]` is a real config — and
+     * reading it as "matches everything" turns a blacklist into `where false`.
+     */
+    readonly matchesNothing: boolean;
+    /** Undefined means the rule applies to every content type. */
+    readonly contentTypes?: readonly string[];
+    /** Criteria that were present but cannot be expressed over a URL. */
+    readonly criteriaOutsideTheUrl: readonly string[];
+    /** Version this rule is parsed under; a rule may override the config's. */
+    readonly ruleSetVersion: number;
+    /** Where the rule came from, e.g. `disabledSites[1]`. For reporting. */
+    readonly source: string;
+}
+export interface StripParameterRule {
+    /** Pages the stripping is limited to, if any. */
+    readonly enabledSites?: readonly NormalizedRule[];
+    /** OR'd parameter-name patterns. */
+    readonly params: readonly ConditionPattern[];
+    /** Resources the stripping is limited to, if any. */
+    readonly rules?: readonly NormalizedRule[];
+    /** Decides whether a parameter name matches exactly or as a prefix. */
+    readonly ruleSetVersion: number;
+    readonly source: string;
+}
+export interface ParsedRuleSets {
+    readonly blacklist: readonly NormalizedRule[];
+    /**
+     * `disabledScopes`, as rules. Not a rule set in the config — a list of path
+     * prefixes the service worker must never claim — but it decides which pages
+     * Speed Kit touches just like `disabledSites` does, so the query treats it
+     * the same way.
+     */
+    readonly disabledScopes: readonly NormalizedRule[];
+    readonly disabledSites: readonly NormalizedRule[];
+    readonly enabledSites: readonly NormalizedRule[];
+    readonly ruleSetVersion: number;
+    readonly stripQueryParams: readonly StripParameterRule[];
+    readonly whitelist: readonly NormalizedRule[];
+}
+/**
+ * The subject a condition is really matched against. A `pathname` condition
+ * reads the query string too unless the rule set is version 2, which makes it
+ * a different subject — and one a query must not compare against the other.
+ */
+export declare function resolvedSubject(subject: RuleSubject, ruleSetVersion: number): ResolvedSubject;
+/** The subjects a query provides, after the version has been resolved. */
+export type ResolvedSubject = "host" | "path" | "pathWithSearch" | "url";
+/**
+ * True when the version matches parameter names and string conditions
+ * exactly. Version 1 treats them as prefixes and also feeds the query string
+ * into `pathname` conditions.
+ *
+ * The comparison is exact, not `>= 2`: `testCondition` in `@speedkit/rules`
+ * checks the version with `=== 2`, so a config declaring anything else falls
+ * back to the version 1 behaviour.
+ */
+export declare function matchesExactly(ruleSetVersion: number): boolean;

package/dist/services/query-builder/rules/rule-model.js

@@ -0,0 +1,54 @@
+import { ConditionKey } from "@speedkit/rules";
+/**
+ * The rule shapes of a Speed Kit config, normalized into something the query
+ * builder can reason about.
+ *
+ * A `SpeedKitRule` in a config is loose: a condition may be a string, a
+ * regular expression or an array of both, a rule may carry criteria that have
+ * nothing to do with the URL, and the rule-set version decides what a string
+ * even means. Everything downstream — relevance, reduction, translation —
+ * works on the types here instead of on the raw config.
+ */
+/** The rule-set version a config runs under when it declares none. */
+export const DEFAULT_RULE_SET_VERSION = 1;
+/** Content types a page impression can have. */
+export const DOCUMENT_CONTENT_TYPES = ["document", "navigate"];
+/** The condition keys naming a part of the URL a query can match on. */
+export const URL_CONDITION_KEYS = [
+    ConditionKey.Host,
+    ConditionKey.Pathname,
+    ConditionKey.Url,
+];
+/**
+ * Criteria of a `SpeedKitRule` that a page impression does not carry, so they
+ * cannot be part of a query. A rule using one of these is either approximated
+ * (when it also has URL conditions) or reported as untranslatable.
+ *
+ * `hashparam` is among them: the runtime matches it against the fragment,
+ * which is not part of a URL the way the warehouse stores it.
+ */
+export const CRITERIA_OUTSIDE_THE_URL = Object.values(ConditionKey).filter((key) => key !== ConditionKey.ContentType &&
+    !URL_CONDITION_KEYS.includes(key));
+/**
+ * The subject a condition is really matched against. A `pathname` condition
+ * reads the query string too unless the rule set is version 2, which makes it
+ * a different subject — and one a query must not compare against the other.
+ */
+export function resolvedSubject(subject, ruleSetVersion) {
+    if (subject !== "pathname") {
+        return subject;
+    }
+    return matchesExactly(ruleSetVersion) ? "path" : "pathWithSearch";
+}
+/**
+ * True when the version matches parameter names and string conditions
+ * exactly. Version 1 treats them as prefixes and also feeds the query string
+ * into `pathname` conditions.
+ *
+ * The comparison is exact, not `>= 2`: `testCondition` in `@speedkit/rules`
+ * checks the version with `=== 2`, so a config declaring anything else falls
+ * back to the version 1 behaviour.
+ */
+export function matchesExactly(ruleSetVersion) {
+    return ruleSetVersion === 2;
+}

package/dist/services/query-builder/rules/rule-parser.d.ts

@@ -0,0 +1,33 @@
+import { ConditionPattern, NormalizedRule, ParsedRuleSets, StripParameterRule } from "./rule-model.js";
+/** Reads the rule sets a query is built from out of an evaluated config. */
+export declare function parseRuleSets(config: unknown): ParsedRuleSets;
+/** The declared rule-set version, or 1 for a config that declares none. */
+export declare function parseRuleSetVersion(config: unknown): number;
+/** Normalizes a `SpeedKitRule[]` — anything else yields no rules. */
+export declare function parseRules(value: unknown, source: string, ruleSetVersion: number): NormalizedRule[];
+/**
+ * Normalizes a `Condition` — a string, a regular expression, or an array of
+ * both — into a flat list of patterns.
+ */
+export declare function parseCondition(value: unknown): ConditionPattern[];
+/**
+ * Turns `disabledScopes` into rules.
+ *
+ * A scope is a service-worker scope, not a Speed Kit condition: a
+ * case-sensitive path prefix, matched on the URL string with no regular
+ * expression and no wildcard, so `/checkout` covers `/checkout/payment` and
+ * `/checkoutTunnel` but not `/en/checkout`. Written as an anchored pattern it
+ * says exactly that, and it can then be read, reduced and translated like
+ * every other rule.
+ *
+ * Pages under a scope are served by an empty service worker, so Speed Kit
+ * never touches them — they belong in neither a pre-warm list nor a parameter
+ * analysis.
+ */
+export declare function parseDisabledScopes(value: unknown): NormalizedRule[];
+/**
+ * Normalizes `stripQueryParams`, which is either a bare condition (every
+ * parameter matching it is stripped everywhere) or a list of rules that scope
+ * the stripping to certain pages or resources.
+ */
+export declare function parseStripQueryParams(value: unknown, ruleSetVersion: number): StripParameterRule[];