@sdxc/flags-engine 0.0.0-pre.1

package/dist/schema.js

@@ -0,0 +1,129 @@
+/**
+ * The parsers that turn stored, untrusted JSON into definitions. They are the
+ * package's published contract for what a flag is, so an admin UI validates a
+ * rule against the same schema before writing what the engine would refuse.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import * as s from "remix/data-schema";
+import { lazy } from "remix/data-schema/lazy";
+/** Reads a value a condition compares against, rejecting anything JSON cannot carry. */
+const JSON_PRIMITIVE_SCHEMA = s.union([
+    s.string(),
+    s.number(),
+    s.boolean(),
+    s.null_(),
+]);
+/**
+ * Reads a variant's value. Arrays are tried before records so a stored list
+ * keeps its shape, and the recursion is deferred because a structure variant
+ * nests without a declared depth.
+ */
+const FLAG_VALUE_SCHEMA = lazy(() => s.union([
+    s.string(),
+    s.number(),
+    s.boolean(),
+    s.null_(),
+    s.array(FLAG_VALUE_SCHEMA),
+    s.record(s.string(), FLAG_VALUE_SCHEMA),
+]));
+/** A dotted path into the evaluation context, which an empty string cannot name. */
+const FIELD_SCHEMA = s.string().refine((field) => field.length > 0, "Expected a context field");
+/**
+ * Holds a discriminant at the literal type it was written as, so the parsed
+ * condition narrows on `op` the way the union it belongs to promises.
+ */
+function operator(name) {
+    return s.literal(name);
+}
+/** The eight comparisons `semver` closes over, so nothing parses a range mini-language. */
+const SEMVER_COMPARISON_SCHEMA = s.enum_(["=", "!=", "<", "<=", ">", ">=", "~", "^"]);
+/**
+ * Reads one targeting condition. Annotated rather than inferred because
+ * `s.variant` widens the discriminant it merges, which would cost every
+ * consumer the narrowing the union exists for.
+ */
+export const CONDITION_SCHEMA = lazy(() => s.variant("op", {
+    all: s.object({ op: operator("all"), of: s.array(CONDITION_SCHEMA) }),
+    any: s.object({ op: operator("any"), of: s.array(CONDITION_SCHEMA) }),
+    not: s.object({ op: operator("not"), of: CONDITION_SCHEMA }),
+    eq: s.object({ op: operator("eq"), field: FIELD_SCHEMA, value: JSON_PRIMITIVE_SCHEMA }),
+    ne: s.object({ op: operator("ne"), field: FIELD_SCHEMA, value: JSON_PRIMITIVE_SCHEMA }),
+    in: s.object({
+        op: operator("in"),
+        field: FIELD_SCHEMA,
+        values: s.array(JSON_PRIMITIVE_SCHEMA),
+    }),
+    notIn: s.object({
+        op: operator("notIn"),
+        field: FIELD_SCHEMA,
+        values: s.array(JSON_PRIMITIVE_SCHEMA),
+    }),
+    lt: s.object({ op: operator("lt"), field: FIELD_SCHEMA, value: s.number() }),
+    lte: s.object({ op: operator("lte"), field: FIELD_SCHEMA, value: s.number() }),
+    gt: s.object({ op: operator("gt"), field: FIELD_SCHEMA, value: s.number() }),
+    gte: s.object({ op: operator("gte"), field: FIELD_SCHEMA, value: s.number() }),
+    startsWith: s.object({
+        op: operator("startsWith"),
+        field: FIELD_SCHEMA,
+        value: s.string(),
+    }),
+    endsWith: s.object({ op: operator("endsWith"), field: FIELD_SCHEMA, value: s.string() }),
+    contains: s.object({ op: operator("contains"), field: FIELD_SCHEMA, value: s.string() }),
+    matches: s.object({ op: operator("matches"), field: FIELD_SCHEMA, pattern: s.string() }),
+    semver: s.object({
+        op: operator("semver"),
+        field: FIELD_SCHEMA,
+        compare: SEMVER_COMPARISON_SCHEMA,
+        value: s.string(),
+    }),
+    exists: s.object({ op: operator("exists"), field: FIELD_SCHEMA }),
+    segment: s.object({ op: operator("segment"), name: s.string() }),
+    always: s.object({ op: operator("always") }),
+}));
+/** A weight, kept whole so a bucket is a count of shares rather than a fraction. */
+const WEIGHT_SCHEMA = s
+    .number()
+    .refine((weight) => Number.isInteger(weight) && weight >= 0, "Expected a whole, non-negative weight");
+/** Sums the weights so a split that could never select an arm is refused at parse time. */
+function hasPositiveTotal(weights) {
+    let total = 0;
+    for (let weight of Object.values(weights))
+        total += weight;
+    return total > 0;
+}
+/** Reads the weighted spread a rule serves instead of naming one variant. */
+export const SPLIT_SCHEMA = s.object({
+    weights: s
+        .record(s.string(), WEIGHT_SCHEMA)
+        .refine(hasPositiveTotal, "Expected weights summing above zero"),
+    by: s.optional(FIELD_SCHEMA),
+    seed: s.optional(s.string()),
+});
+/** Reads one targeting row, whose `serve` is either a variant name or a split. */
+export const TARGETING_RULE_SCHEMA = s.object({
+    when: CONDITION_SCHEMA,
+    serve: s.union([s.string(), SPLIT_SCHEMA]),
+});
+/** Reads the properties a resolution of this flag carries to whatever reads the event. */
+const FLAG_METADATA_SCHEMA = s.record(s.string(), s.union([s.string(), s.number(), s.boolean()]));
+/**
+ * Reads one flag. A flag with no variants is refused here, so every later step
+ * is choosing among values that exist.
+ */
+export const FLAG_DEFINITION_SCHEMA = s.object({
+    variants: s
+        .record(s.string(), FLAG_VALUE_SCHEMA)
+        .refine((variants) => Object.keys(variants).length > 0, "Expected at least one variant"),
+    defaultVariant: s.optional(s.string()),
+    state: s.optional(s.enum_(["enabled", "disabled"])),
+    targeting: s.optional(s.array(TARGETING_RULE_SCHEMA)),
+    metadata: s.optional(FLAG_METADATA_SCHEMA),
+});
+/**
+ * Reads a whole segment map at once, for an editor validating what it is about
+ * to write. The engine reads segments one at a time so a bad one costs only the
+ * flags that reference it.
+ */
+export const SEGMENT_SET_SCHEMA = s.record(s.string(), CONDITION_SCHEMA);

package/dist/snapshot.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The form the engine holds a definition set in once it has been parsed:
+ * segments already resolved, patterns already compiled, variant names already
+ * checked, so evaluating a flag walks a structure known to be well formed.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { FlagMetadata, FlagValue } from "@sdxc/flags";
+import type { JSONPrimitive } from "@sdxc/types";
+import type { FlagState, SemVerComparison, Split } from "./definition.js";
+/**
+ * A condition with the two parts evaluation cannot do cheaply already done: a
+ * `matches` pattern is a compiled expression, and a `segment` carries the
+ * condition it names, so no operator reaches back to the snapshot to resolve.
+ */
+export type CompiledCondition = {
+    op: "all";
+    of: CompiledCondition[];
+} | {
+    op: "any";
+    of: CompiledCondition[];
+} | {
+    op: "not";
+    of: CompiledCondition;
+} | {
+    op: "eq" | "ne";
+    field: string;
+    value: JSONPrimitive;
+} | {
+    op: "in" | "notIn";
+    field: string;
+    values: JSONPrimitive[];
+} | {
+    op: "lt" | "lte" | "gt" | "gte";
+    field: string;
+    value: number;
+} | {
+    op: "startsWith" | "endsWith" | "contains";
+    field: string;
+    value: string;
+} | {
+    op: "matches";
+    field: string;
+    pattern: RegExp;
+} | {
+    op: "semver";
+    field: string;
+    compare: SemVerComparison;
+    value: string;
+} | {
+    op: "exists";
+    field: string;
+} | {
+    op: "segment";
+    name: string;
+    of: CompiledCondition;
+} | {
+    op: "always";
+};
+/** One targeting row, whose `serve` is known to name variants the flag declares. */
+export interface CompiledRule {
+    when: CompiledCondition;
+    serve: string | Split;
+}
+/** Every segment that resolved, by the name a condition references it under. */
+export type CompiledSegments = ReadonlyMap<string, CompiledCondition>;
+/**
+ * A flag ready to evaluate. `defaultVariant`, every `serve` and every split
+ * weight name a variant in `variants`, so selecting a variant is a lookup that
+ * hits.
+ */
+export interface CompiledFlag {
+    key: string;
+    variants: ReadonlyMap<string, FlagValue>;
+    /** Absent when the flag falls back to the value the caller passed. */
+    defaultVariant?: string;
+    state: FlagState;
+    /** Empty when the flag serves its default unconditionally, which reads as `STATIC`. */
+    targeting: readonly CompiledRule[];
+    metadata?: FlagMetadata;
+}
+/**
+ * A definition the set carried and the engine refused. It is what every
+ * evaluation of that key answers with, as `PARSE_ERROR` and this message, and
+ * what a caller logs once after a load.
+ */
+export interface FlagParseFailure {
+    key: string;
+    /** Why the definition was refused, phrased for a log line or an `errorMessage`. */
+    message: string;
+}
+/**
+ * A parsed definition set, and the whole of what evaluation reads. A key is in
+ * `flags` or in `failures` and never both, so a broken definition answers for
+ * itself while every other flag in the set resolves.
+ */
+export interface FlagSnapshot {
+    flags: ReadonlyMap<string, CompiledFlag>;
+    failures: ReadonlyMap<string, FlagParseFailure>;
+    segments: CompiledSegments;
+    /** What the store called this revision, for a caller that caches snapshots. */
+    version?: string;
+    /** Epoch milliseconds this snapshot was stamped at, so staleness needs no clock to evaluate. */
+    createdAt: number;
+}

package/dist/snapshot.js

@@ -0,0 +1,8 @@
+/**
+ * The form the engine holds a definition set in once it has been parsed:
+ * segments already resolved, patterns already compiled, variant names already
+ * checked, so evaluating a flag walks a structure known to be well formed.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */

package/dist/store/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Where definitions come from: one read that answers with the whole set, the
+ * shape it answers in, and the single failure type it reports. Implemented by
+ * every store, and the only thing the engine knows about storage.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { MaybePromise } from "@sdxc/flags";
+import type { Result } from "@sdxc/result";
+/**
+ * A definition set as a store holds it. Values arrive as `unknown` because
+ * producing the JSON is the store's job and deciding whether that JSON is a
+ * valid flag is the engine's, in one place against one schema.
+ */
+export interface StoredFlagSet {
+    flags: Record<string, unknown>;
+    segments?: Record<string, unknown>;
+    /** What the store calls this revision, for a caller that caches snapshots. */
+    version?: string;
+}
+/**
+ * A source of flag definitions. The engine asks for everything at once because
+ * segments are shared across flags and a store is read once per snapshot, so
+ * the query that matters is the one that fills it.
+ *
+ * `read` may answer synchronously, so a store already holding its set in memory
+ * costs no promise.
+ */
+export interface FlagStore {
+    read(): MaybePromise<Result<StoredFlagSet, FlagStoreError>>;
+}
+/**
+ * Normalized reason a store could not hand over its set. A caller branches on
+ * this; whatever the underlying storage threw travels alongside as `cause`.
+ */
+export type FlagStoreErrorCode = 
+/** The storage could not be reached, or refused the read. */
+"unavailable"
+/** The storage answered, and what it holds is not JSON. */
+ | "invalid_value";
+/** What a store states about a failure when it constructs the error. */
+export interface FlagStoreErrorOptions extends ErrorOptions {
+    code: FlagStoreErrorCode;
+    /** Where the store looked, such as the key a value was read from. */
+    location?: string;
+}
+/**
+ * Failure carried by every `FlagStore` result.
+ *
+ * An empty store is a success holding an empty set, so reaching this type means
+ * the definitions exist somewhere and could not be obtained — a configuration
+ * failure a caller reports, rather than a flag falling back.
+ *
+ * @example
+ * failure(new FlagStoreError("KV refused the get", { code: "unavailable" }));
+ */
+export declare class FlagStoreError extends Error {
+    name: string;
+    readonly code: FlagStoreErrorCode;
+    /** Where the store looked, such as the key a value was read from. */
+    readonly location?: string;
+    /**
+     * @param message What went wrong, for a log or a rethrow.
+     * @param options The code, where the store looked, and the original error as `cause`.
+     */
+    constructor(message: string, { code, location, ...options }: FlagStoreErrorOptions);
+}

package/dist/store/index.js

@@ -0,0 +1,33 @@
+/**
+ * Where definitions come from: one read that answers with the whole set, the
+ * shape it answers in, and the single failure type it reports. Implemented by
+ * every store, and the only thing the engine knows about storage.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/**
+ * Failure carried by every `FlagStore` result.
+ *
+ * An empty store is a success holding an empty set, so reaching this type means
+ * the definitions exist somewhere and could not be obtained — a configuration
+ * failure a caller reports, rather than a flag falling back.
+ *
+ * @example
+ * failure(new FlagStoreError("KV refused the get", { code: "unavailable" }));
+ */
+export class FlagStoreError extends Error {
+    name = "FlagStoreError";
+    code;
+    /** Where the store looked, such as the key a value was read from. */
+    location;
+    /**
+     * @param message What went wrong, for a log or a rethrow.
+     * @param options The code, where the store looked, and the original error as `cause`.
+     */
+    constructor(message, { code, location, ...options }) {
+        super(message, options);
+        this.code = code;
+        this.location = location;
+    }
+}

package/dist/store/memory.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A store holding its definitions in an object, for tests and for a set compiled
+ * into the worker that reads it. It answers a read synchronously, so a caller
+ * whose flags are already in memory pays a function call to load them.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { Result } from "@sdxc/result";
+import type { FlagStore, FlagStoreError, StoredFlagSet } from "./index.js";
+/**
+ * Holds one definition set for the life of the instance.
+ *
+ * Every read hands over a copy, so a caller walking a set keeps reading what it
+ * read while the store goes on being written to.
+ */
+export declare class InMemoryFlagStore implements FlagStore {
+    #private;
+    /**
+     * @param set The definitions the store starts out holding, empty by default.
+     */
+    constructor(set?: StoredFlagSet);
+    /**
+     * @returns The set being held, always as a success: definitions in memory are
+     * reachable by the code that holds them.
+     */
+    read(): Result<StoredFlagSet, FlagStoreError>;
+    /**
+     * Replaces the whole set, which is the write a store backed by one value takes.
+     * It lives on the store that has the capability, so an admin path writes through
+     * the same object every reader reads through.
+     *
+     * @param set The definitions every later read answers with.
+     */
+    write(set: StoredFlagSet): void;
+}

package/dist/store/memory.js

@@ -0,0 +1,41 @@
+/**
+ * A store holding its definitions in an object, for tests and for a set compiled
+ * into the worker that reads it. It answers a read synchronously, so a caller
+ * whose flags are already in memory pays a function call to load them.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import { success } from "@sdxc/result";
+/**
+ * Holds one definition set for the life of the instance.
+ *
+ * Every read hands over a copy, so a caller walking a set keeps reading what it
+ * read while the store goes on being written to.
+ */
+export class InMemoryFlagStore {
+    #set;
+    /**
+     * @param set The definitions the store starts out holding, empty by default.
+     */
+    constructor(set = { flags: {} }) {
+        this.#set = set;
+    }
+    /**
+     * @returns The set being held, always as a success: definitions in memory are
+     * reachable by the code that holds them.
+     */
+    read() {
+        return success(structuredClone(this.#set));
+    }
+    /**
+     * Replaces the whole set, which is the write a store backed by one value takes.
+     * It lives on the store that has the capability, so an admin path writes through
+     * the same object every reader reads through.
+     *
+     * @param set The definitions every later read answers with.
+     */
+    write(set) {
+        this.#set = set;
+    }
+}

package/dist/store/worker-kv.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A store over a Cloudflare KV namespace, holding the whole definition set as one
+ * JSON value under one key. Filling a snapshot is a single `get` served from the
+ * edge cache, and an admin write rewrites the value.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { Result } from "@sdxc/result";
+import type { FlagStore, StoredFlagSet } from "./index.js";
+import { FlagStoreError } from "./index.js";
+/** Where a Worker KV store keeps its set. */
+export interface WorkerKVFlagStoreOptions {
+    /**
+     * The key the whole set is stored under. An application holding more than one set
+     * gives each of them its own.
+     *
+     * @default "flags"
+     */
+    key?: string;
+}
+/**
+ * Reads and writes one definition set in a KV namespace.
+ *
+ * A key holding nothing reads as an empty set, so a namespace an admin has yet to
+ * write to is a working store rather than a failure a caller has to special-case.
+ */
+export declare class WorkerKVFlagStore implements FlagStore {
+    #private;
+    /** The key the set lives under, for a caller that also manages the namespace. */
+    readonly key: string;
+    /**
+     * @param kv The namespace the set is stored in.
+     * @param options The key the set lives under.
+     */
+    constructor(kv: KVNamespace, { key }?: WorkerKVFlagStoreOptions);
+    /**
+     * @returns The stored set, an empty one when the key holds nothing, `invalid_value`
+     * when what it holds is not a JSON object, and `unavailable` when the namespace
+     * refused the read.
+     */
+    read(): Promise<Result<StoredFlagSet, FlagStoreError>>;
+    /**
+     * Replaces the whole set, which is the write a store backed by one value takes.
+     * It lives on the store that has the capability, so an admin path writes through
+     * the same key every reader reads through.
+     *
+     * @param set The definitions every later read answers with.
+     * @returns Nothing on success, `invalid_value` for a set JSON cannot write, and
+     * `unavailable` when the namespace refused the put.
+     */
+    write(set: StoredFlagSet): Promise<Result<void, FlagStoreError>>;
+}

package/dist/store/worker-kv.js

@@ -0,0 +1,123 @@
+/**
+ * A store over a Cloudflare KV namespace, holding the whole definition set as one
+ * JSON value under one key. Filling a snapshot is a single `get` served from the
+ * edge cache, and an admin write rewrites the value.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import { failure, success } from "@sdxc/result";
+import { FlagStoreError } from "./index.js";
+/** The key the set lives under when the caller names none. */
+const DEFAULT_KEY = "flags";
+/** Whether the value is a JSON object, which is what both a set and its flags are. */
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Whether a parsed value is a set, which it is when it carries flags as an object.
+ * That is as far as a store looks: what a definition has to be is the engine's
+ * question, answered in one place against one schema.
+ *
+ * @param value What the stored JSON parsed to.
+ */
+function isFlagSet(value) {
+    return isRecord(value) && isRecord(value["flags"]);
+}
+/**
+ * Reads and writes one definition set in a KV namespace.
+ *
+ * A key holding nothing reads as an empty set, so a namespace an admin has yet to
+ * write to is a working store rather than a failure a caller has to special-case.
+ */
+export class WorkerKVFlagStore {
+    #kv;
+    /** The key the set lives under, for a caller that also manages the namespace. */
+    key;
+    /**
+     * @param kv The namespace the set is stored in.
+     * @param options The key the set lives under.
+     */
+    constructor(kv, { key = DEFAULT_KEY } = {}) {
+        this.#kv = kv;
+        this.key = key;
+    }
+    /**
+     * @returns The stored set, an empty one when the key holds nothing, `invalid_value`
+     * when what it holds is not a JSON object, and `unavailable` when the namespace
+     * refused the read.
+     */
+    async read() {
+        let text;
+        try {
+            text = await this.#kv.get(this.key, "text");
+        }
+        catch (cause) {
+            return failure(this.#refused("read", cause));
+        }
+        if (text === null)
+            return success({ flags: {} });
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch (cause) {
+            return failure(new FlagStoreError(`The value stored at ${this.key} is not JSON.`, {
+                code: "invalid_value",
+                location: this.key,
+                cause,
+            }));
+        }
+        if (!isFlagSet(value)) {
+            return failure(new FlagStoreError(`The value stored at ${this.key} holds no flags object.`, {
+                code: "invalid_value",
+                location: this.key,
+            }));
+        }
+        return success(value);
+    }
+    /**
+     * Replaces the whole set, which is the write a store backed by one value takes.
+     * It lives on the store that has the capability, so an admin path writes through
+     * the same key every reader reads through.
+     *
+     * @param set The definitions every later read answers with.
+     * @returns Nothing on success, `invalid_value` for a set JSON cannot write, and
+     * `unavailable` when the namespace refused the put.
+     */
+    async write(set) {
+        let text;
+        try {
+            text = JSON.stringify(set);
+        }
+        catch (cause) {
+            return failure(new FlagStoreError(`The set given for ${this.key} cannot be written as JSON.`, {
+                code: "invalid_value",
+                location: this.key,
+                cause,
+            }));
+        }
+        try {
+            await this.#kv.put(this.key, text);
+        }
+        catch (cause) {
+            return failure(this.#refused("write", cause));
+        }
+        return success(undefined);
+    }
+    /**
+     * States a namespace failure as the code a caller branches on, carrying what KV
+     * threw so the original reason survives the translation.
+     *
+     * @param operation What was being attempted, which the message names.
+     * @param cause What the namespace threw.
+     */
+    #refused(operation, cause) {
+        let reason = cause instanceof Error ? cause.message : String(cause);
+        return new FlagStoreError(`The namespace could not ${operation} ${this.key}: ${reason}`, {
+            code: "unavailable",
+            location: this.key,
+            cause,
+        });
+    }
+}

package/dist/testing/conformance.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The suite that says what a flag store is, registered as Vitest tests against
+ * whatever the caller constructs. Every store runs it, the one an application
+ * writes against its own tables included, which is what makes them substitutes.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { FlagStore, StoredFlagSet } from "../store/index.js";
+/** What the suite needs to exercise a store. */
+export interface ConformanceOptions<Store extends FlagStore = FlagStore> {
+    /** Store name, which labels the registered suite. */
+    name: string;
+    /**
+     * Builds the store under test, holding nothing. It is called for every test, so a
+     * store over shared storage points each one at a location of its own.
+     */
+    create: () => Store | Promise<Store>;
+    /**
+     * Puts the set where the store reads it from, by whatever means the storage gives.
+     * A store with a write of its own seeds through it, and a read-only store seeds
+     * through the file, endpoint or object behind it.
+     */
+    seed: (store: Store, set: StoredFlagSet) => void | Promise<void>;
+    /**
+     * Stores the set through the store's own write. Supplying it registers the round
+     * trip assertions, which say a store reads back what it was told to hold.
+     */
+    write?: (store: Store, set: StoredFlagSet) => void | Promise<void>;
+    /**
+     * Puts text where the store reads it from, in place of anything the store would
+     * serialize. Supplying it registers the assertions about a value the store did not
+     * write, which is where a store either reports or throws.
+     */
+    writeText?: (store: Store, text: string) => void | Promise<void>;
+}
+/**
+ * Registers the suite every flag store has to pass.
+ *
+ * @param options The store under test, and the capabilities it has beyond reading.
+ * @example conformance({ name: "worker-kv", create: () => new WorkerKVFlagStore(env.FLAGS), seed })
+ */
+export declare function conformance<Store extends FlagStore>({ name, create, seed, write, writeText, }: ConformanceOptions<Store>): void;