@shelbyb/daywalker-sdk 0.1.4 → 0.3.0

package/dist/flags/common/sse.js

@@ -0,0 +1,183 @@
+/** Incremental parser: feed it chunks of text, get dispatched events back. */
+export class SseParser {
+    buffer = "";
+    data = [];
+    eventType = "";
+    sawFirstChunk = false;
+    /** The previous chunk ended in CR, so an LF starting this chunk completes a CRLF. */
+    pendingCR = false;
+    lastEventId = "";
+    retry = null;
+    feed(chunk) {
+        if (!this.sawFirstChunk) {
+            this.sawFirstChunk = true;
+            if (chunk.charCodeAt(0) === 0xfeff)
+                chunk = chunk.slice(1); // strip BOM
+        }
+        if (this.pendingCR && chunk.startsWith("\n"))
+            chunk = chunk.slice(1);
+        this.pendingCR = false;
+        this.buffer += chunk;
+        const out = [];
+        // Lines end with CRLF, LF or CR. A CR ends the line immediately (so events
+        // dispatch without waiting for more bytes); an LF right after it is skipped.
+        let start = 0;
+        for (let i = 0; i < this.buffer.length; i++) {
+            const c = this.buffer[i];
+            if (c !== "\n" && c !== "\r")
+                continue;
+            const line = this.buffer.slice(start, i);
+            if (c === "\r") {
+                if (i === this.buffer.length - 1)
+                    this.pendingCR = true;
+                else if (this.buffer[i + 1] === "\n")
+                    i++;
+            }
+            start = i + 1;
+            const ev = this.line(line);
+            if (ev)
+                out.push(ev);
+        }
+        this.buffer = this.buffer.slice(start);
+        return out;
+    }
+    line(line) {
+        if (line === "") {
+            if (!this.data.length) {
+                this.eventType = "";
+                return null;
+            }
+            const ev = { type: this.eventType || "message", data: this.data.join("\n"), lastEventId: this.lastEventId };
+            this.data = [];
+            this.eventType = "";
+            return ev;
+        }
+        if (line.startsWith(":"))
+            return null;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let value = colon === -1 ? "" : line.slice(colon + 1);
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        switch (field) {
+            case "event":
+                this.eventType = value;
+                break;
+            case "data":
+                this.data.push(value);
+                break;
+            case "id":
+                if (!value.includes("\0"))
+                    this.lastEventId = value;
+                break;
+            case "retry":
+                if (/^\d+$/.test(value))
+                    this.retry = Number(value);
+                break;
+        }
+        return null;
+    }
+}
+export class SseError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+    /** 4xx (except 408/429) won't succeed on retry. */
+    get recoverable() {
+        return this.status === undefined || this.status >= 500 || this.status === 408 || this.status === 429;
+    }
+}
+/** Exponential backoff with full jitter, reset after a stable connection. */
+export function backoffDelay(attempt, base, max) {
+    const exp = Math.min(max, base * 2 ** Math.min(attempt, 10));
+    return Math.round(exp / 2 + Math.random() * (exp / 2));
+}
+export class SseClient {
+    opts;
+    controller = null;
+    stopped = false;
+    attempt = 0;
+    parser = new SseParser();
+    timer = null;
+    watchdog = null;
+    reader = null;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    start() {
+        this.stopped = false;
+        void this.connect();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        // Don't leave the read-timeout timer or a pending read keeping the process alive.
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.controller?.abort();
+        void this.reader?.cancel().catch(() => { });
+    }
+    /** Drop the current connection and reconnect immediately (e.g. after identify). */
+    restart() {
+        this.controller?.abort();
+        this.attempt = 0;
+        this.parser = new SseParser();
+        if (!this.stopped)
+            void this.connect();
+    }
+    async connect() {
+        if (this.stopped)
+            return;
+        const controller = new AbortController();
+        this.controller = controller;
+        const f = this.opts.fetch ?? fetch;
+        const resetWatchdog = () => {
+            if (this.watchdog)
+                clearTimeout(this.watchdog);
+            this.watchdog = setTimeout(() => controller.abort(), this.opts.readTimeoutMs ?? 5 * 60_000);
+        };
+        const connectedAt = Date.now();
+        try {
+            const url = typeof this.opts.url === "function" ? this.opts.url() : this.opts.url;
+            const headers = typeof this.opts.headers === "function" ? this.opts.headers() : (this.opts.headers ?? {});
+            resetWatchdog();
+            const res = await f(url, {
+                headers: { accept: "text/event-stream", "cache-control": "no-cache", ...(this.parser.lastEventId ? { "last-event-id": this.parser.lastEventId } : {}), ...headers },
+                signal: controller.signal,
+            });
+            if (!res.ok || !res.body)
+                throw new SseError(`Stream request failed with ${res.status}`, res.status);
+            this.opts.onOpen?.();
+            const reader = res.body.getReader();
+            this.reader = reader;
+            const decoder = new TextDecoder();
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                resetWatchdog();
+                for (const ev of this.parser.feed(decoder.decode(value, { stream: true })))
+                    this.opts.onEvent(ev);
+            }
+            throw new SseError("Stream closed by server");
+        }
+        catch (err) {
+            if (this.watchdog)
+                clearTimeout(this.watchdog);
+            if (this.stopped || (controller.signal.aborted && this.controller !== controller))
+                return;
+            const e = err instanceof SseError ? err : new SseError(err?.message ?? "Stream error");
+            const keepGoing = this.opts.onError?.(e);
+            if (keepGoing === false || !e.recoverable)
+                return;
+            if (Date.now() - connectedAt > 60_000)
+                this.attempt = 0; // was healthy for a while
+            const base = this.parser.retry ?? this.opts.initialRetryMs ?? 1000;
+            const delay = backoffDelay(this.attempt++, base, this.opts.maxRetryMs ?? 30_000);
+            this.timer = setTimeout(() => void this.connect(), delay);
+        }
+    }
+}

package/dist/flags/engine/bucket.d.ts

@@ -0,0 +1,21 @@
+import { type Context } from "./context.js";
+import type { Rollout } from "./types.js";
+/**
+ * Deterministic bucket in [0, 1) for a context. Compatible with LaunchDarkly:
+ * sha1("<flagKey>.<salt>.<value>") (or "<seed>.<value>" for seeded rollouts),
+ * first 15 hex digits divided by 0xFFFFFFFFFFFFFFF.
+ * Returns null when the context lacks the rollout's context kind.
+ */
+export declare function bucketContext(ctx: Context, key: string, salt: string, opts: {
+    contextKind?: string;
+    bucketBy?: string;
+    seed?: number;
+}): {
+    bucket: number;
+    found: boolean;
+};
+/** Pick a variation from a rollout. `inExperiment` is true for tracked experiment buckets. */
+export declare function variationForRollout(ctx: Context, flagKey: string, salt: string, rollout: Rollout): {
+    variation: number;
+    inExperiment: boolean;
+} | null;

package/dist/flags/engine/bucket.js

@@ -0,0 +1,41 @@
+import { getAttribute } from "./context.js";
+import { sha1Hex } from "./sha1.js";
+const LONG_SCALE = 0xfffffffffffffff; // 15 hex digits
+/**
+ * Deterministic bucket in [0, 1) for a context. Compatible with LaunchDarkly:
+ * sha1("<flagKey>.<salt>.<value>") (or "<seed>.<value>" for seeded rollouts),
+ * first 15 hex digits divided by 0xFFFFFFFFFFFFFFF.
+ * Returns null when the context lacks the rollout's context kind.
+ */
+export function bucketContext(ctx, key, salt, opts) {
+    const kind = opts.contextKind ?? "user";
+    const single = ctx.kinds.get(kind);
+    if (!single)
+        return { bucket: 0, found: false };
+    const raw = getAttribute(single, opts.bucketBy ?? "key");
+    let id;
+    if (typeof raw === "string")
+        id = raw;
+    else if (typeof raw === "number" && Number.isInteger(raw))
+        id = String(raw);
+    else
+        return { bucket: 0, found: true };
+    const input = opts.seed !== undefined ? `${opts.seed}.${id}` : `${key}.${salt}.${id}`;
+    return { bucket: parseInt(sha1Hex(input).slice(0, 15), 16) / LONG_SCALE, found: true };
+}
+/** Pick a variation from a rollout. `inExperiment` is true for tracked experiment buckets. */
+export function variationForRollout(ctx, flagKey, salt, rollout) {
+    if (!rollout.variations.length)
+        return null;
+    const { bucket, found } = bucketContext(ctx, flagKey, salt, rollout);
+    const isExperiment = rollout.kind === "experiment";
+    let sum = 0;
+    for (const wv of rollout.variations) {
+        sum += wv.weight / 100000;
+        if (bucket < sum)
+            return { variation: wv.variation, inExperiment: isExperiment && found && !wv.untracked };
+    }
+    // Rounding or weights < 100%: fall into the last bucket.
+    const last = rollout.variations[rollout.variations.length - 1];
+    return { variation: last.variation, inExperiment: isExperiment && found && !last.untracked };
+}

package/dist/flags/engine/context.d.ts

@@ -0,0 +1,30 @@
+import type { FlagValue } from "./types.js";
+/**
+ * Evaluation contexts. Either a single-kind context
+ *   { kind: "user", key: "u1", email: "a@b.c" }
+ * or a multi-kind context
+ *   { kind: "multi", user: { key: "u1" }, organization: { key: "acme" } }
+ * A context without `kind` is treated as a "user" context.
+ */
+export type ContextInput = Record<string, unknown>;
+export interface SingleContext {
+    kind: string;
+    key: string;
+    anonymous: boolean;
+    attributes: Record<string, unknown>;
+    privateAttributes: string[];
+}
+export interface Context {
+    kinds: Map<string, SingleContext>;
+    /** Stable key for the whole context: the key for single contexts, `kind:key` pairs for multi. */
+    canonicalKey: string;
+}
+export declare class ContextError extends Error {
+}
+export declare function parseContext(input: unknown): Context;
+/**
+ * Resolve an attribute reference. Plain names are looked up literally;
+ * references starting with "/" are RFC 6901 JSON Pointers into nested objects.
+ */
+export declare function getAttribute(ctx: SingleContext, ref: string): unknown;
+export declare function isFlagValue(v: unknown): v is FlagValue;

package/dist/flags/engine/context.js

@@ -0,0 +1,81 @@
+const KIND_RE = /^[a-zA-Z0-9._-]+$/;
+export class ContextError extends Error {
+}
+function parseSingle(kind, raw) {
+    if (!KIND_RE.test(kind) || kind === "kind" || kind === "multi")
+        throw new ContextError(`Invalid context kind "${kind}"`);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new ContextError(`Context "${kind}" must be an object`);
+    const obj = raw;
+    if (typeof obj.key !== "string" || obj.key === "")
+        throw new ContextError(`Context "${kind}" needs a non-empty string key`);
+    const meta = (obj._meta ?? {});
+    const privateAttributes = Array.isArray(meta.privateAttributes) ? meta.privateAttributes.filter((a) => typeof a === "string") : [];
+    // No prototype: `constructor`, `toString`, `__proto__` resolve only if the context sets them.
+    const attributes = Object.create(null);
+    for (const [k, v] of Object.entries(obj))
+        if (k !== "_meta" && k !== "kind")
+            attributes[k] = v;
+    return { kind, key: obj.key, anonymous: obj.anonymous === true, attributes, privateAttributes };
+}
+/** Escape ":" and "%" in canonical keys, as LaunchDarkly does. */
+const esc = (s) => s.replace(/%/g, "%25").replace(/:/g, "%3A");
+export function parseContext(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new ContextError("Context must be an object");
+    const obj = input;
+    const kinds = new Map();
+    if (obj.kind === "multi") {
+        for (const [kind, raw] of Object.entries(obj))
+            if (kind !== "kind")
+                kinds.set(kind, parseSingle(kind, raw));
+        if (kinds.size === 0)
+            throw new ContextError("A multi-kind context needs at least one kind");
+    }
+    else {
+        const kind = typeof obj.kind === "string" ? obj.kind : "user";
+        kinds.set(kind, parseSingle(kind, obj));
+    }
+    const canonicalKey = kinds.size === 1 && kinds.has("user")
+        ? kinds.get("user").key
+        : [...kinds.values()]
+            .sort((a, b) => a.kind.localeCompare(b.kind))
+            .map((c) => `${c.kind}:${esc(c.key)}`)
+            .join(":");
+    return { kinds, canonicalKey };
+}
+/**
+ * Resolve an attribute reference. Plain names are looked up literally;
+ * references starting with "/" are RFC 6901 JSON Pointers into nested objects.
+ */
+export function getAttribute(ctx, ref) {
+    if (ref === "kind")
+        return ctx.kind;
+    if (ref === "key")
+        return ctx.key;
+    if (!ref.startsWith("/"))
+        return Object.hasOwn(ctx.attributes, ref) ? ctx.attributes[ref] : undefined;
+    const tokens = ref
+        .slice(1)
+        .split("/")
+        .map((t) => t.replace(/~1/g, "/").replace(/~0/g, "~"));
+    let cur = ctx.attributes;
+    for (const [i, t] of tokens.entries()) {
+        if (i === 0 && t === "key")
+            return ctx.key;
+        if (cur === null || typeof cur !== "object")
+            return undefined;
+        if (Array.isArray(cur)) {
+            if (!/^(0|[1-9]\d*)$/.test(t))
+                return undefined;
+            cur = cur[Number(t)];
+        }
+        else {
+            cur = Object.hasOwn(cur, t) ? cur[t] : undefined;
+        }
+    }
+    return cur;
+}
+export function isFlagValue(v) {
+    return v === null || ["string", "number", "boolean"].includes(typeof v) || typeof v === "object";
+}

package/dist/flags/engine/evaluate.d.ts

@@ -0,0 +1,54 @@
+import { type Context } from "./context.js";
+import type { DataStore, EvaluationDetail, EvaluationReason, FlagConfig, FlagValue, SegmentConfig } from "./types.js";
+export interface PrerequisiteEvaluation {
+    flag: FlagConfig;
+    prerequisiteOf: string;
+    detail: EvaluationDetail;
+}
+export interface EvaluationResult {
+    detail: EvaluationDetail;
+    /** Prerequisite flags evaluated along the way (for analytics events). */
+    prerequisites: PrerequisiteEvaluation[];
+}
+/**
+ * Evaluates flags against contexts. Pure and synchronous: the same inputs
+ * always produce the same output on every platform.
+ */
+export declare class Evaluator {
+    private readonly store;
+    constructor(store: DataStore);
+    evaluate(flag: FlagConfig, context: Context): EvaluationResult;
+    private evalFlag;
+    private serve;
+    private variation;
+    private off;
+    private clauseMatches;
+    private segmentMatches;
+}
+export declare function errorDetail(errorKind: Extract<EvaluationReason, {
+    kind: "ERROR";
+}>["errorKind"], value?: FlagValue): EvaluationDetail;
+/**
+ * Convenience: evaluate a flag by key for raw context input, returning the
+ * default value (with an ERROR reason) when anything goes wrong.
+ */
+export declare function evaluateFlag<T extends FlagValue>(store: DataStore, flagKey: string, contextInput: unknown, defaultValue: T): EvaluationDetail<T> & {
+    prerequisites: PrerequisiteEvaluation[];
+};
+/** Plain in-memory store, handy for SDKs and tests. */
+export declare class MemoryStore implements DataStore {
+    flags: Map<string, FlagConfig>;
+    segments: Map<string, SegmentConfig>;
+    constructor(data?: {
+        flags?: Record<string, FlagConfig>;
+        segments?: Record<string, SegmentConfig>;
+    });
+    replace(data: {
+        flags?: Record<string, FlagConfig>;
+        segments?: Record<string, SegmentConfig>;
+    }): void;
+    /** Apply a versioned upsert; stale versions are ignored. Returns true when applied. */
+    upsert(kind: "flag" | "segment", item: FlagConfig | SegmentConfig): boolean;
+    getFlag(key: string): FlagConfig | undefined;
+    getSegment(key: string): SegmentConfig | undefined;
+}

package/dist/flags/engine/evaluate.js

@@ -0,0 +1,177 @@
+import { bucketContext, variationForRollout } from "./bucket.js";
+import { ContextError, getAttribute, parseContext } from "./context.js";
+import { applyOperator } from "./operators.js";
+const MAX_SEGMENT_DEPTH = 10;
+class MalformedFlag extends Error {
+}
+/**
+ * Evaluates flags against contexts. Pure and synchronous: the same inputs
+ * always produce the same output on every platform.
+ */
+export class Evaluator {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    evaluate(flag, context) {
+        const prerequisites = [];
+        try {
+            const detail = this.evalFlag(flag, context, prerequisites, new Set());
+            return { detail, prerequisites };
+        }
+        catch (err) {
+            if (err instanceof MalformedFlag)
+                return { detail: errorDetail("MALFORMED_FLAG"), prerequisites };
+            return { detail: errorDetail("EXCEPTION"), prerequisites };
+        }
+    }
+    evalFlag(flag, ctx, events, visiting) {
+        if (!flag.on)
+            return this.off(flag, { kind: "OFF" });
+        if (visiting.has(flag.key))
+            throw new MalformedFlag(`Prerequisite cycle at ${flag.key}`);
+        visiting.add(flag.key);
+        try {
+            for (const pre of flag.prerequisites) {
+                const preFlag = this.store.getFlag(pre.key);
+                if (!preFlag || preFlag.deleted)
+                    return this.off(flag, { kind: "PREREQUISITE_FAILED", prerequisiteKey: pre.key });
+                const detail = this.evalFlag(preFlag, ctx, events, visiting);
+                events.push({ flag: preFlag, prerequisiteOf: flag.key, detail });
+                if (!preFlag.on || detail.variationIndex !== pre.variation) {
+                    return this.off(flag, { kind: "PREREQUISITE_FAILED", prerequisiteKey: pre.key });
+                }
+            }
+        }
+        finally {
+            visiting.delete(flag.key);
+        }
+        for (const target of flag.targets) {
+            const single = ctx.kinds.get(target.contextKind ?? "user");
+            if (single && target.values.includes(single.key))
+                return this.variation(flag, target.variation, { kind: "TARGET_MATCH" });
+        }
+        for (const [ruleIndex, rule] of flag.rules.entries()) {
+            if (rule.clauses.every((c) => this.clauseMatches(c, ctx, 0))) {
+                return this.serve(flag, rule, ctx, (inExperiment) => ({ kind: "RULE_MATCH", ruleIndex, ruleId: rule.id, ...(inExperiment ? { inExperiment } : {}) }));
+            }
+        }
+        return this.serve(flag, flag.fallthrough, ctx, (inExperiment) => ({ kind: "FALLTHROUGH", ...(inExperiment ? { inExperiment } : {}) }));
+    }
+    serve(flag, vr, ctx, reason) {
+        if (vr.variation !== undefined && vr.variation !== null)
+            return this.variation(flag, vr.variation, reason(false));
+        if (vr.rollout) {
+            const picked = variationForRollout(ctx, flag.key, flag.salt, vr.rollout);
+            if (!picked)
+                throw new MalformedFlag("Empty rollout");
+            return this.variation(flag, picked.variation, reason(picked.inExperiment));
+        }
+        throw new MalformedFlag("Rule has neither variation nor rollout");
+    }
+    variation(flag, index, reason) {
+        if (!Number.isInteger(index) || index < 0 || index >= flag.variations.length)
+            throw new MalformedFlag(`Invalid variation ${index}`);
+        return { value: flag.variations[index], variationIndex: index, reason };
+    }
+    off(flag, reason) {
+        if (flag.offVariation === null || flag.offVariation === undefined)
+            return { value: null, variationIndex: null, reason };
+        return this.variation(flag, flag.offVariation, reason);
+    }
+    clauseMatches(clause, ctx, depth) {
+        if (clause.op === "segmentMatch") {
+            const matched = clause.values.some((key) => typeof key === "string" && this.segmentMatches(key, ctx, depth));
+            return clause.negate ? !matched : matched;
+        }
+        // The special "kind" attribute matches against every kind in the context.
+        if (clause.attribute === "kind") {
+            const matched = [...ctx.kinds.keys()].some((k) => clause.values.some((v) => applyOperator(clause.op, k, v)));
+            return clause.negate ? !matched : matched;
+        }
+        const single = ctx.kinds.get(clause.contextKind ?? "user");
+        if (!single)
+            return false; // missing context kind never matches, even when negated
+        const actual = getAttribute(single, clause.attribute);
+        if (actual === undefined || actual === null)
+            return false;
+        const candidates = Array.isArray(actual) ? actual : [actual];
+        const matched = candidates.some((a) => clause.values.some((v) => applyOperator(clause.op, a, v)));
+        return clause.negate ? !matched : matched;
+    }
+    segmentMatches(key, ctx, depth) {
+        if (depth >= MAX_SEGMENT_DEPTH)
+            throw new MalformedFlag("Segment nesting too deep");
+        const seg = this.store.getSegment(key);
+        if (!seg || seg.deleted)
+            return false;
+        const inList = (list) => list.some((t) => {
+            const single = ctx.kinds.get(t.contextKind ?? "user");
+            return !!single && t.values.includes(single.key);
+        });
+        if (inList(seg.included))
+            return true;
+        if (inList(seg.excluded))
+            return false;
+        for (const rule of seg.rules) {
+            if (!rule.clauses.every((c) => this.clauseMatches(c, ctx, depth + 1)))
+                continue;
+            if (rule.weight === undefined || rule.weight === null)
+                return true;
+            const { bucket } = bucketContext(ctx, seg.key, seg.salt, { contextKind: rule.rolloutContextKind, bucketBy: rule.bucketBy });
+            return bucket < rule.weight / 100000;
+        }
+        return false;
+    }
+}
+export function errorDetail(errorKind, value = null) {
+    return { value, variationIndex: null, reason: { kind: "ERROR", errorKind } };
+}
+/**
+ * Convenience: evaluate a flag by key for raw context input, returning the
+ * default value (with an ERROR reason) when anything goes wrong.
+ */
+export function evaluateFlag(store, flagKey, contextInput, defaultValue) {
+    let ctx;
+    try {
+        ctx = parseContext(contextInput);
+    }
+    catch (err) {
+        return { ...errorDetail(err instanceof ContextError ? "USER_NOT_SPECIFIED" : "EXCEPTION", defaultValue), prerequisites: [] };
+    }
+    const flag = store.getFlag(flagKey);
+    if (!flag || flag.deleted)
+        return { ...errorDetail("FLAG_NOT_FOUND", defaultValue), prerequisites: [] };
+    const { detail, prerequisites } = new Evaluator(store).evaluate(flag, ctx);
+    if (detail.reason.kind === "ERROR" || detail.variationIndex === null)
+        return { ...detail, value: defaultValue, prerequisites };
+    return { ...detail, prerequisites };
+}
+/** Plain in-memory store, handy for SDKs and tests. */
+export class MemoryStore {
+    flags = new Map();
+    segments = new Map();
+    constructor(data) {
+        if (data)
+            this.replace(data);
+    }
+    replace(data) {
+        this.flags = new Map(Object.entries(data.flags ?? {}));
+        this.segments = new Map(Object.entries(data.segments ?? {}));
+    }
+    /** Apply a versioned upsert; stale versions are ignored. Returns true when applied. */
+    upsert(kind, item) {
+        const map = (kind === "flag" ? this.flags : this.segments);
+        const cur = map.get(item.key);
+        if (cur && cur.version >= item.version)
+            return false;
+        map.set(item.key, item);
+        return true;
+    }
+    getFlag(key) {
+        return this.flags.get(key);
+    }
+    getSegment(key) {
+        return this.segments.get(key);
+    }
+}

package/dist/flags/engine/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export { parseContext, getAttribute, ContextError, type Context, type ContextInput, type SingleContext } from "./context.js";
+export { Evaluator, MemoryStore, evaluateFlag, errorDetail, type EvaluationResult, type PrerequisiteEvaluation } from "./evaluate.js";
+export { bucketContext, variationForRollout } from "./bucket.js";
+export { applyOperator, parseTime } from "./operators.js";
+export { parseSemVer, compareSemVer } from "./semver.js";
+export { sha1Hex } from "./sha1.js";

package/dist/flags/engine/index.js

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export { parseContext, getAttribute, ContextError } from "./context.js";
+export { Evaluator, MemoryStore, evaluateFlag, errorDetail } from "./evaluate.js";
+export { bucketContext, variationForRollout } from "./bucket.js";
+export { applyOperator, parseTime } from "./operators.js";
+export { parseSemVer, compareSemVer } from "./semver.js";
+export { sha1Hex } from "./sha1.js";

package/dist/flags/engine/operators.d.ts

@@ -0,0 +1,13 @@
+import type { FlagValue, Operator } from "./types.js";
+/** `matches` limits: longer inputs or patterns never match. */
+export declare const MAX_MATCH_INPUT_LENGTH = 1024;
+export declare const MAX_MATCH_PATTERN_LENGTH = 500;
+/**
+ * Conservative ReDoS heuristic: a group that contains a quantifier or alternation and is itself
+ * repeated (`(a+)+`, `(a*)*`, `(a|aa)+`, `(?:x+y)*`, `(a+){2,}`). Character classes and escapes are skipped.
+ */
+export declare function hasNestedQuantifier(pattern: string): boolean;
+/** RFC 3339 timestamp or Unix milliseconds → epoch ms. */
+export declare function parseTime(v: unknown): number | null;
+/** Compare one context value with one clause value. Type mismatches never match. */
+export declare function applyOperator(op: Exclude<Operator, "segmentMatch">, actual: unknown, expected: FlagValue): boolean;