flagrm 0.4.0 → 0.5.0

package/dist/core/markdown.js

@@ -68,3 +68,60 @@ export function verifyMarkdown(report, root) {
     }
     return `${out.join("\n")}\n`;
 }
+/** One environment in a few words: `production true 45d`, `staging targeted (1 rule(s))`. */
+export function staleEnvironmentText(e) {
+    if (e.serves === "targeted")
+        return `${e.environment} targeted (${e.detail})`;
+    const days = e.days === undefined ? "" : ` ${e.days}d${e.sinceSource === "lastModified" ? "*" : ""}`;
+    return `${e.environment} ${JSON.stringify(e.value)}${days}`;
+}
+/** The conditions a report applied, in one line. */
+export function staleConditionsText(report) {
+    const c = report.conditions;
+    const parts = [
+        `boolean, true in ${c.environments.join(", ") || "no environment"} for ${c.minDaysOn}+ days`,
+        ...(c.temporaryOnly ? ["temporary"] : []),
+        ...(c.tags.include.length ? [`tags ${c.tags.include.join(", ")}`] : []),
+        ...(c.tags.exclude.length ? [`not tagged ${c.tags.exclude.join(", ")}`] : []),
+    ];
+    return parts.join("; ");
+}
+const STALE_TITLES = {
+    remove: "Ready to remove",
+    keep: "Keep",
+    unreferenced: "Not referenced in this repository",
+};
+/** `flagrm stale --md`: the flags per verdict, for a pull request or a pipeline summary. */
+export function staleMarkdown(report) {
+    const count = (v) => report.flags.filter((f) => f.verdict === v).length;
+    const out = [
+        `### flagrm stale: ${report.project} — ${count("remove")} ready to remove`,
+        "",
+        `_Conditions: ${staleConditionsText(report)}. Evaluated ${report.evaluatedAt}._`,
+    ];
+    const cell = (text) => text.replace(/\|/g, "\\|");
+    for (const verdict of ["remove", "keep"]) {
+        const flags = report.flags.filter((f) => f.verdict === verdict);
+        if (!flags.length)
+            continue;
+        const columns = ["Flag", "Code name", "Environments", ...(verdict === "keep" ? ["Reasons"] : [])];
+        out.push("", `**${STALE_TITLES[verdict]} (${flags.length})**`, "", `| ${columns.join(" | ")} |`, `|${"---|".repeat(columns.length)}`);
+        for (const f of flags) {
+            const cells = [
+                f.key ? `\`${f.key}\`` : "—",
+                f.codeName ? `\`${f.codeName}\`` : "—",
+                cell(f.environments.map(staleEnvironmentText).join(", ") || "—"),
+                ...(verdict === "keep" ? [cell(f.reasons.join("; "))] : []),
+            ];
+            out.push(`| ${cells.join(" | ")} |`);
+        }
+    }
+    const unreferenced = report.flags.filter((f) => f.verdict === "unreferenced").map((f) => f.key ?? "");
+    if (unreferenced.length) {
+        out.push("", `**${STALE_TITLES.unreferenced} (${unreferenced.length}):** ${codeList(unreferenced)}`, "", "_Another repository may still read these; flagrm doesn't recommend archiving them._");
+    }
+    if (report.flags.some((f) => f.environments.some((e) => e.sinceSource === "lastModified"))) {
+        out.push("", "_\\* days since the environment last changed: the audit log had no targeting change to date._");
+    }
+    return out.join("\n");
+}

package/dist/core/report.js

@@ -1,4 +1,5 @@
 import pc from "picocolors";
+import { staleConditionsText, staleEnvironmentText } from "./markdown.js";
 import { reusedNote } from "./run-cache.js";
 import { plural, relativePath } from "./util.js";
 /** A path relative to the working directory, with `/` separators on every platform. */
@@ -136,6 +137,7 @@ const STEP_STYLE = {
     updated: pc.green,
     unchanged: pc.dim,
     skipped: pc.dim,
+    deleted: pc.yellow,
 };
 /** One line per `init`/`update` step: `created   .claude/skills/flagrm-remove`. */
 export function printSteps(steps) {
@@ -189,3 +191,31 @@ export function printScope(setups, root, written) {
             console.log(pc.dim("  A solution filter can't help here: install the SDK or change global.json."));
     }
 }
+const STALE_STYLE = {
+    remove: { title: "Ready to remove", color: pc.green },
+    keep: { title: "Keep", color: pc.yellow },
+    unreferenced: { title: "Not referenced in this repository (another may still read them)", color: pc.dim },
+};
+/** `flagrm stale`: the flags grouped by verdict, each with its environments and reasons. */
+export function printStale(report) {
+    console.log(pc.bold(`LaunchDarkly project ${report.project}`) + pc.dim(` — ${staleConditionsText(report)}`));
+    for (const verdict of ["remove", "keep", "unreferenced"]) {
+        const flags = report.flags.filter((f) => f.verdict === verdict);
+        if (!flags.length)
+            continue;
+        const { title, color } = STALE_STYLE[verdict];
+        console.log(`\n${color(pc.bold(`${title} (${flags.length})`))}`);
+        for (const f of flags) {
+            const name = f.key && f.codeName && f.key !== f.codeName ? `${f.key} → ${f.codeName}` : (f.key ?? f.codeName);
+            const envs = f.environments.map(staleEnvironmentText).join(", ");
+            console.log(`  ${name}${envs ? pc.dim(`  ${envs}`) : ""}`);
+            for (const reason of verdict === "unreferenced" ? [] : f.reasons)
+                console.log(pc.dim(`      ${reason}`));
+        }
+    }
+    if (report.flags.length === 0)
+        console.log(pc.dim("\nNo flags."));
+    if (report.flags.some((f) => f.environments.some((e) => e.sinceSource === "lastModified"))) {
+        console.log(pc.dim("\n* days since the environment last changed: the audit log had no targeting change to date."));
+    }
+}

package/dist/core/run-cache.js

@@ -6,7 +6,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import fg from "fast-glob";
+import { globSync } from "tinyglobby";
 import { flagDir, matchingFiles, runChecks } from "./baseline.js";
 import { changeFilter } from "./change-filter.js";
 import { configSnapshot, projectCommands } from "./config-snapshot.js";
@@ -69,7 +69,12 @@ export function saveRuns(root, flag, projects, key, runs, createdAt = new Date()
 }
 /** Forget every saved set, of any flag, for this tree: a fresh run on it failed, so they may hide a flaky test or a changed machine. */
 export function dropRuns(root, key) {
-    for (const file of fg.sync(".flagrm/*/verify/runs.json", { cwd: root, absolute: true, dot: true })) {
+    for (const file of globSync(".flagrm/*/verify/runs.json", {
+        expandDirectories: false,
+        cwd: root,
+        absolute: true,
+        dot: true,
+    })) {
         if (readJson(file)?.key === key)
             fs.rmSync(file, { force: true });
     }
@@ -81,7 +86,12 @@ export function findRuns(root, projects, key, needed) {
     const commands = JSON.stringify(configSnapshot(projects).projects);
     const version = packageVersion();
     let best;
-    for (const file of fg.sync(".flagrm/*/verify/runs.json", { cwd: root, absolute: true, dot: true })) {
+    for (const file of globSync(".flagrm/*/verify/runs.json", {
+        expandDirectories: false,
+        cwd: root,
+        absolute: true,
+        dot: true,
+    })) {
         const saved = readJson(file);
         if (!saved || !Array.isArray(saved.runs) || typeof saved.createdAt !== "string")
             continue;

package/dist/core/scan.js

@@ -1,5 +1,6 @@
+import fs from "node:fs";
 import path from "node:path";
-import fg from "fast-glob";
+import { globSync, isDynamicPattern } from "tinyglobby";
 export const BACKEND_GLOBS = [
     "**/*.cs",
     "**/*.cshtml",
@@ -19,11 +20,37 @@ export const IGNORE_GLOBS = [
     "**/.angular/**",
     "**/.git/**",
 ];
-/** Absolute paths with the platform's separators (fast-glob returns `/` on Windows too), so they match `path.join`. */
+/**
+ * Files matching an absolute path or glob, such as a `testResults` pattern,
+ * as absolute paths with `/`. The leading directories that exist are taken
+ * literally and become the glob's `cwd`, so a repository path containing
+ * glob characters (`/work/p[x]/TestResults/*.trx`) still matches.
+ */
+export function globAbsolute(pattern) {
+    const segments = (path.sep === "\\" ? pattern.replace(/\\/g, "/") : pattern).split("/");
+    let base = segments[0] === "" ? "/" : `${segments[0]}/`;
+    let i = 1;
+    for (; i < segments.length - 1; i++) {
+        const dir = path.posix.join(base, segments[i]);
+        if (isDynamicPattern(segments[i]) && !isDirectory(dir))
+            break;
+        base = dir;
+    }
+    return globSync(segments.slice(i).join("/"), { expandDirectories: false, cwd: base, absolute: true, dot: true });
+}
+function isDirectory(dir) {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Absolute paths with the platform's separators (tinyglobby returns `/` on Windows too), so they match `path.join`. */
 export function listProjectFiles(root, globs, overrides) {
     const patterns = [...globs, ...(overrides?.include ?? [])];
     const ignore = [...IGNORE_GLOBS, ...(overrides?.exclude ?? [])];
-    return fg.sync(patterns, { cwd: root, ignore, absolute: true, dot: false }).map((file) => path.normalize(file));
+    return globSync(patterns, { expandDirectories: false, cwd: root, ignore, absolute: true, dot: false }).map((file) => path.normalize(file));
 }
 export function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/dist/core/scope.js

@@ -8,7 +8,7 @@
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import fg from "fast-glob";
+import { globSync } from "tinyglobby";
 import YAML from "yaml";
 import { sdkProblem, solutionSetup } from "../adapters/dotnet/setup.js";
 import { projectCommands } from "./config-snapshot.js";
@@ -81,8 +81,8 @@ function solutionFor(ctx, commands) {
             return { note: `can't read ${arg}` };
         }
     }
-    const found = fg.sync("*.{sln,slnx}", { cwd: ctx.root, absolute: true });
-    // fast-glob returns forward slashes, also on Windows.
+    const found = globSync("*.{sln,slnx}", { expandDirectories: false, cwd: ctx.root, absolute: true });
+    // tinyglobby returns forward slashes, also on Windows.
     if (found.length === 1)
         return { solution: path.normalize(found[0]) };
     return { note: found.length ? "several solutions: name one in build/test" : "no solution file found" };

package/dist/core/sources/launchdarkly.js

@@ -0,0 +1,331 @@
+/**
+ * Reads a LaunchDarkly project through the REST API (GET only): its
+ * environments, every non-archived flag with full targeting, and, for the
+ * flags that could be removed, the audit log to date the last targeting change.
+ * `fetch` and `sleep` are injectable so tests never touch the network or wait.
+ */
+import { SourceError } from "./types.js";
+export const LD_API_VERSION = "20240415";
+const TIMEOUT_MS = 30_000;
+const MAX_RETRIES = 5;
+const MAX_WAIT_MS = 60_000;
+const PAGE_SIZE = 100;
+/** Environments requested per flags listing: kept small, since each adds full targeting to every flag. */
+const ENVIRONMENTS_PER_LISTING = 3;
+/** The audit log returns at most 20 entries per page. */
+const AUDIT_PAGE_SIZE = 20;
+const AUDIT_PAGES = 5;
+/**
+ * Audit-log actions that don't change what an environment serves. Any other
+ * action, including one LaunchDarkly adds later, resets `since`: an unknown
+ * action can then only shorten the time a flag counts as ON, never lengthen it.
+ */
+export const NON_TARGETING_ACTIONS = new Set([
+    "updateName",
+    "updateDescription",
+    "updateTags",
+    "updateTemporary",
+    "updateMaintainer",
+    "updateDeprecated",
+    "updateIncludeInSnippet",
+    "updateClientSideFlagAvailability",
+    "updateFlagCustomProperties",
+    "updateFlagLinks",
+    "updateTrackEvents",
+    "updateTrackEventsFallthrough",
+    "updateFlagSalt",
+    "createApprovalRequest",
+    "reviewApprovalRequest",
+    "deleteApprovalRequest",
+    "updateApprovalRequest",
+    "createTriggers",
+    "updateTriggers",
+    "deleteTriggers",
+]);
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const iso = (ms) => new Date(ms).toISOString();
+export class LaunchDarklySource {
+    config;
+    options;
+    fetch;
+    sleep;
+    now;
+    constructor(config, options) {
+        this.config = config;
+        this.options = options;
+        this.fetch = options.fetch ?? globalThis.fetch;
+        this.sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+        this.now = options.now ?? Date.now;
+    }
+    async read(wantsHistory) {
+        const environments = await this.environments();
+        const flags = await this.flags(environments);
+        for (const { flag, raw } of flags) {
+            if (flag.unrecognized)
+                continue;
+            const history = wantsHistory(flag);
+            for (const [env, state] of Object.entries(flag.environments)) {
+                if (state.serves.kind !== "fixed")
+                    continue;
+                const lastModified = raw[env].lastModified;
+                const audit = history ? await this.lastTargetingChange(flag.key, env) : undefined;
+                state.since = iso(audit ?? lastModified);
+                state.sinceSource = audit === undefined ? "lastModified" : "audit";
+            }
+        }
+        return { environments, flags: flags.map((f) => f.flag) };
+    }
+    /** The checked environments: the configured ones, which must exist, or all of the project's. */
+    async environments() {
+        const project = encodeURIComponent(this.config.project);
+        const keys = [];
+        const environmentsUrl = `/api/v2/projects/${project}/environments?limit=${PAGE_SIZE}`;
+        for await (const item of this.pages(environmentsUrl, this.projectNotFound())) {
+            if (typeof item.key === "string")
+                keys.push(item.key);
+        }
+        const wanted = this.config.environments;
+        if (!wanted)
+            return keys;
+        const unknown = wanted.filter((e) => !keys.includes(e));
+        if (unknown.length) {
+            throw new Error(`launchdarkly.environments: ${unknown.map((e) => `"${e}"`).join(", ")} not in LaunchDarkly project ` +
+                `"${this.config.project}". Its environments: ${keys.join(", ") || "none"}.`);
+        }
+        return wanted;
+    }
+    /**
+     * Every non-archived flag with what each environment serves; `raw` keeps each environment's JSON.
+     * The listing leaves archived flags out unless asked for them (`filter=state:archived`), so no filter is sent.
+     */
+    async flags(environments) {
+        const project = encodeURIComponent(this.config.project);
+        const byKey = new Map();
+        for (let i = 0; i < environments.length; i += ENVIRONMENTS_PER_LISTING) {
+            const batch = environments.slice(i, i + ENVIRONMENTS_PER_LISTING);
+            const envParams = batch.map((e) => `&env=${encodeURIComponent(e)}`).join("");
+            const flagsUrl = `/api/v2/flags/${project}?summary=0&limit=${PAGE_SIZE}${envParams}`;
+            for await (const item of this.pages(flagsUrl, this.projectNotFound())) {
+                const key = typeof item.key === "string" ? item.key : undefined;
+                if (!key)
+                    continue;
+                const entry = byKey.get(key) ?? { item, envs: {} };
+                if (isObject(item.environments))
+                    Object.assign(entry.envs, item.environments);
+                byKey.set(key, entry);
+            }
+        }
+        return [...byKey.values()].map(({ item, envs }) => ({ flag: parseFlag(item, envs, environments), raw: envs }));
+    }
+    /** Epoch ms of the latest audit entry for the flag in `env` that may have changed targeting; undefined when none. */
+    async lastTargetingChange(flagKey, env) {
+        const spec = `proj/${this.config.project}:env/${env}:flag/${flagKey}`;
+        let before;
+        for (let page = 0; page < AUDIT_PAGES; page++) {
+            const query = `spec=${encodeURIComponent(spec)}&limit=${AUDIT_PAGE_SIZE}${before ? `&before=${before}` : ""}`;
+            const body = await this.get(`/api/v2/auditlog?${query}`);
+            const items = Array.isArray(body.items) ? body.items.filter(isObject) : [];
+            const dated = items.filter((i) => typeof i.date === "number");
+            // The log lists newest first, but take the latest targeting entry of the page rather than rely on it.
+            const changes = dated.filter(changesTargeting).map((i) => i.date);
+            if (changes.length)
+                return Math.max(...changes);
+            if (dated.length < AUDIT_PAGE_SIZE)
+                return undefined;
+            before = Math.min(...dated.map((i) => i.date));
+        }
+        return undefined;
+    }
+    /** Each item of a paginated listing, following `_links.next`. */
+    async *pages(first, notFound) {
+        for (let next = first; next;) {
+            const body = await this.get(next, notFound);
+            if (!Array.isArray(body.items))
+                throw new SourceError(`LaunchDarkly returned no items list for GET ${next}`);
+            yield* body.items.filter(isObject);
+            const links = isObject(body._links) && isObject(body._links.next) ? body._links.next : undefined;
+            next = typeof links?.href === "string" ? links.href : undefined;
+        }
+    }
+    /**
+     * GET `target` as JSON, retrying rate limits; every failure is a {@link SourceError}, a 404 with `notFound`
+     * as its message when given. `target` is a path rooted at `baseUrl`, or a `_links` URL on the same origin.
+     */
+    async get(target, notFound) {
+        const url = this.resolve(target);
+        const endpoint = new URL(url).pathname;
+        for (let attempt = 0;; attempt++) {
+            let res;
+            try {
+                res = await this.fetch(url, {
+                    method: "GET",
+                    headers: { Authorization: this.options.token, "LD-API-Version": LD_API_VERSION, Accept: "application/json" },
+                    signal: AbortSignal.timeout(TIMEOUT_MS),
+                });
+            }
+            catch (err) {
+                throw new SourceError(this.redact(networkMessage(err, endpoint)));
+            }
+            if (res.status === 429 && attempt < MAX_RETRIES) {
+                await this.sleep(this.retryWait(res.headers));
+                continue;
+            }
+            if (res.ok) {
+                try {
+                    const body = await res.json();
+                    if (isObject(body))
+                        return body;
+                }
+                catch {
+                    // reported below
+                }
+                throw new SourceError(`LaunchDarkly returned a response that isn't a JSON object for GET ${endpoint}`);
+            }
+            const message = res.status === 404 && notFound ? `${notFound} (404) at GET ${endpoint}` : undefined;
+            throw new SourceError(this.redact(message ?? this.statusMessage(res.status, endpoint)));
+        }
+    }
+    /**
+     * The URL for a path (`/api/v2/...`, appended to `baseUrl`) or an absolute `_links` URL. An absolute URL
+     * must be on `baseUrl`'s origin: the token is sent with the request, so it never goes to another host.
+     */
+    resolve(target) {
+        if (target.startsWith("/"))
+            return `${this.config.baseUrl}${target}`;
+        let url;
+        try {
+            url = new URL(target);
+        }
+        catch {
+            throw new SourceError(`LaunchDarkly returned a link flagrm can't follow: ${target}`);
+        }
+        if (url.origin !== new URL(this.config.baseUrl).origin) {
+            throw new SourceError(`LaunchDarkly returned a link to another host (${url.origin}); not following it`);
+        }
+        return url.href;
+    }
+    projectNotFound() {
+        return `LaunchDarkly project "${this.config.project}" not found`;
+    }
+    statusMessage(status, endpoint) {
+        const { project, tokenEnv } = this.config;
+        if (status === 401)
+            return `LaunchDarkly rejected the token in ${tokenEnv} (401) for GET ${endpoint}`;
+        if (status === 403) {
+            return `The token in ${tokenEnv} may not read LaunchDarkly project "${project}" (403) for GET ${endpoint}`;
+        }
+        if (status === 404)
+            return `LaunchDarkly found nothing (404) at GET ${endpoint}`;
+        if (status === 429)
+            return `LaunchDarkly kept rate-limiting (429) after ${MAX_RETRIES} retries for GET ${endpoint}`;
+        return `LaunchDarkly answered ${status} for GET ${endpoint}`;
+    }
+    /** Milliseconds to wait before retrying a 429: the longest the headers ask for, at most a minute. */
+    retryWait(headers) {
+        const waits = [];
+        for (const name of ["X-Ratelimit-Reset", "X-Ratelimit-Auth-Token-Reset"]) {
+            const reset = Number(headers.get(name));
+            if (headers.get(name) && Number.isFinite(reset))
+                waits.push(reset - this.now());
+        }
+        const retryAfter = Number(headers.get("Retry-After"));
+        if (headers.get("Retry-After") && Number.isFinite(retryAfter))
+            waits.push(retryAfter * 1000);
+        const wait = waits.length ? Math.max(...waits) : 1000;
+        return Math.min(MAX_WAIT_MS, Math.max(0, wait));
+    }
+    /** Belt and braces: no message may carry the token, whatever an error echoes back. */
+    redact(message) {
+        const { token } = this.options;
+        return token ? message.split(token).join("***") : message;
+    }
+}
+function networkMessage(err, endpoint) {
+    const e = err;
+    if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+        return `LaunchDarkly didn't answer within ${TIMEOUT_MS / 1000} s for GET ${endpoint}`;
+    }
+    const cause = e?.cause?.code ?? e?.cause?.message ?? e?.message ?? String(err);
+    return `Couldn't reach LaunchDarkly (${cause}) for GET ${endpoint}`;
+}
+/** Whether an audit entry may have changed what the environment serves. */
+function changesTargeting(entry) {
+    const accesses = Array.isArray(entry.accesses) ? entry.accesses.filter(isObject) : [];
+    // An entry without readable actions counts as a change: unknown can only shorten the ON time.
+    if (accesses.length === 0)
+        return true;
+    return accesses.some((a) => typeof a.action !== "string" || !NON_TARGETING_ACTIONS.has(a.action));
+}
+const nonEmpty = (v) => Array.isArray(v) && v.length > 0;
+/**
+ * What one environment serves, from its targeting: `fixed` only when every
+ * context gets one variation. Undefined when the data isn't what flagrm expects.
+ */
+export function servedValue(env, variations) {
+    const variation = (index) => typeof index === "number" && Number.isInteger(index) && index >= 0 && index < variations.length
+        ? { kind: "fixed", value: variations[index].value }
+        : undefined;
+    for (const field of ["targets", "contextTargets", "rules", "prerequisites"]) {
+        if (env[field] !== undefined && env[field] !== null && !Array.isArray(env[field]))
+            return undefined;
+    }
+    if (typeof env.on !== "boolean")
+        return undefined;
+    if (!env.on) {
+        if (env.offVariation === undefined || env.offVariation === null) {
+            return { kind: "targeted", detail: "targeting off without an off variation (the code's fallback is served)" };
+        }
+        return variation(env.offVariation);
+    }
+    const count = (field) => (Array.isArray(env[field]) ? env[field].length : 0);
+    if (nonEmpty(env.prerequisites))
+        return { kind: "targeted", detail: `${count("prerequisites")} prerequisite(s)` };
+    if (nonEmpty(env.rules))
+        return { kind: "targeted", detail: `${count("rules")} rule(s)` };
+    if (nonEmpty(env.targets) || nonEmpty(env.contextTargets))
+        return { kind: "targeted", detail: "individual targets" };
+    if (!isObject(env.fallthrough))
+        return undefined;
+    if (env.fallthrough.rollout !== undefined && env.fallthrough.rollout !== null) {
+        return { kind: "targeted", detail: "a percentage rollout" };
+    }
+    return variation(env.fallthrough.variation);
+}
+/** A {@link SourceFlag} from one flags-listing item; `unrecognized` says what didn't parse. */
+export function parseFlag(item, envs, environments) {
+    const key = String(item.key);
+    const flag = {
+        key,
+        name: typeof item.name === "string" ? item.name : key,
+        kind: typeof item.kind === "string" ? item.kind : "unknown",
+        temporary: item.temporary === true,
+        tags: Array.isArray(item.tags) ? item.tags.filter((t) => typeof t === "string") : [],
+        creationDate: typeof item.creationDate === "number" ? iso(item.creationDate) : "",
+        environments: {},
+    };
+    const problems = [];
+    if (typeof item.kind !== "string")
+        problems.push("no kind");
+    if (typeof item.temporary !== "boolean")
+        problems.push("no temporary marker");
+    if (!Array.isArray(item.variations) || !item.variations.every(isObject))
+        problems.push("no variations");
+    for (const env of environments) {
+        const raw = envs[env];
+        if (!isObject(raw)) {
+            problems.push(`no targeting for environment "${env}"`);
+            continue;
+        }
+        const serves = Array.isArray(item.variations) ? servedValue(raw, item.variations) : undefined;
+        if (!serves)
+            problems.push(`unreadable targeting in "${env}"`);
+        else if (serves.kind === "fixed" && typeof raw.lastModified !== "number") {
+            problems.push(`no lastModified in "${env}"`);
+        }
+        else
+            flag.environments[env] = { serves };
+    }
+    if (problems.length)
+        flag.unrecognized = `unrecognized LaunchDarkly data: ${problems.join(", ")}`;
+    return flag;
+}

package/dist/core/sources/types.js

@@ -0,0 +1,13 @@
+/**
+ * A flag service flagrm reads flags from, for `flagrm stale`. Read-only: a
+ * source never writes to the service. LaunchDarkly is the only one today;
+ * another service is a new file implementing {@link FlagSource}.
+ */
+/**
+ * The service couldn't be asked: unreachable, timed out, rejected the token,
+ * unknown project, rate limit retries used up. `flagrm stale` exits 3 on it.
+ * Messages name the endpoint, never the token.
+ */
+export class SourceError extends Error {
+    name = "SourceError";
+}