@bondedhq/shared 0.0.0-stage → 0.1.0

package/dist/module-install.js

@@ -0,0 +1,133 @@
+import { encodeAbiParameters, encodeFunctionData } from "viem";
+import { mandateModuleFactoryAbi } from "./abis.js";
+import { withMandateCommitment } from "./schemas/mandate-commitment.js";
+/**
+ * The ERC-7579 account functions used to install a MandateModule and to batch calls.
+ * `mode` is the ERC-7579 ModeCode (bytes32).
+ */
+export const erc7579AccountAbi = [
+    {
+        type: "function",
+        name: "execute",
+        stateMutability: "payable",
+        inputs: [
+            { name: "mode", type: "bytes32" },
+            { name: "executionCalldata", type: "bytes" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "installModule",
+        stateMutability: "payable",
+        inputs: [
+            { name: "moduleTypeId", type: "uint256" },
+            { name: "module", type: "address" },
+            { name: "initData", type: "bytes" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "uninstallModule",
+        stateMutability: "payable",
+        inputs: [
+            { name: "moduleTypeId", type: "uint256" },
+            { name: "module", type: "address" },
+            { name: "deInitData", type: "bytes" },
+        ],
+        outputs: [],
+    },
+    {
+        type: "function",
+        name: "isModuleInstalled",
+        stateMutability: "view",
+        inputs: [
+            { name: "moduleTypeId", type: "uint256" },
+            { name: "module", type: "address" },
+            { name: "additionalContext", type: "bytes" },
+        ],
+        outputs: [{ name: "", type: "bool" }],
+    },
+];
+/** ERC-7579 module types MandateModule is installed as. */
+export const MODULE_TYPE_EXECUTOR = 2n;
+export const MODULE_TYPE_HOOK = 4n;
+/** ERC-7579 mode for a batch of calls that reverts if any fails (call type 0x01). */
+export const ERC7579_BATCH_MODE = `0x01${"00".repeat(31)}`;
+/** Init data for installing MandateModule as a hook on `accountType`. */
+export function hookInstallData(accountType) {
+    if (accountType === "erc7579")
+        return "0x";
+    // Safe7579: abi.encode(HookType.GLOBAL (0), bytes4(0), bytes(""))
+    return encodeAbiParameters([{ type: "uint8" }, { type: "bytes4" }, { type: "bytes" }], [0, "0x00000000", "0x"]);
+}
+/** The three calls, for a module address already known (see `prepareModuleInstall`). */
+export function moduleInstallCalls(input) {
+    const params = withMandateCommitment(input.params);
+    const install = (moduleType, initData) => ({
+        to: input.account,
+        value: 0n,
+        data: encodeFunctionData({
+            abi: erc7579AccountAbi,
+            functionName: "installModule",
+            args: [moduleType, input.module, initData],
+        }),
+    });
+    return [
+        {
+            to: input.moduleFactory,
+            value: 0n,
+            data: encodeFunctionData({
+                abi: mandateModuleFactoryAbi,
+                functionName: "createModule",
+                args: [params, input.agent, input.guardian, input.agentId],
+            }),
+        },
+        install(MODULE_TYPE_EXECUTOR, "0x"),
+        install(MODULE_TYPE_HOOK, hookInstallData(input.accountType)),
+    ];
+}
+/** Calls as an ERC-7579 batch for `account.execute`. */
+export function erc7579Batch(calls) {
+    const executionCalldata = encodeAbiParameters([
+        {
+            type: "tuple[]",
+            components: [
+                { name: "target", type: "address" },
+                { name: "value", type: "uint256" },
+                { name: "callData", type: "bytes" },
+            ],
+        },
+    ], [calls.map((c) => ({ target: c.to, value: c.value, callData: c.data }))]);
+    return {
+        mode: ERC7579_BATCH_MODE,
+        executionCalldata,
+        data: encodeFunctionData({
+            abi: erc7579AccountAbi,
+            functionName: "execute",
+            args: [ERC7579_BATCH_MODE, executionCalldata],
+        }),
+    };
+}
+/**
+ * Everything an account needs to create and install its MandateModule in one transaction:
+ * reads the module's future address from the factory, then builds createModule followed by
+ * installModule as executor and as hook. Send `calls` as a Safe MultiSend from the Safe, or
+ * `execute.data` to an ERC-7579 account (for example as a user operation's call data).
+ *
+ * The predicted address assumes nothing changes in between: the account creates no other
+ * module first and the vault factory's oracle stays the same.
+ */
+export async function prepareModuleInstall(client, input) {
+    const params = withMandateCommitment(input.params);
+    const module = (await client.readContract({
+        address: input.moduleFactory,
+        abi: mandateModuleFactoryAbi,
+        functionName: "predictModule",
+        args: [input.account, params, input.agent, input.guardian, input.agentId],
+    }));
+    const calls = moduleInstallCalls({ ...input, params, module });
+    return { module, params, calls, execute: erc7579Batch(calls) };
+}
+//# sourceMappingURL=module-install.js.map

package/dist/notifications.d.ts

@@ -0,0 +1,48 @@
+/**
+ * What Bonded tells an agent's owner about (webhook, optional email and the in-app list,
+ * `GET /self/notifications/inbox`). Each type can be turned off in the owner's settings
+ * (`muted`). Each event is sent once: its `dedupeKey` names it.
+ */
+export declare const NOTIFICATION_TYPES: {
+    readonly rating_finished: "A rating or preview finished.";
+    readonly rating_failed: "A rating or preview stopped.";
+    readonly rating_refused: "A rating or preview was refused (not attested).";
+    readonly score_expiring: "The agent's score expires in 7 days.";
+    readonly runner_offline: "The runner has been offline for over 30 minutes while a rating or renewal is due.";
+    readonly breach_recorded: "The vault recorded a breach.";
+    readonly claim_filed: "A claim was filed for a breach.";
+    readonly claim_paid: "A claim was paid.";
+    readonly cover_lapsing: "The cover's premium is past due (in its grace period) or the cover lapsed.";
+    readonly low_gas: "The agent key is low on gas.";
+};
+export type NotificationType = keyof typeof NOTIFICATION_TYPES;
+export declare const NOTIFICATION_TYPE_LIST: NotificationType[];
+/** How long before a score's expiry the owner is told. */
+export declare const SCORE_EXPIRY_WARNING_SECONDS: number;
+/** How long a runner may be away, while a rating or renewal is due, before the owner is told. */
+export declare const RUNNER_OFFLINE_ALERT_MS: number;
+/**
+ * The agent key pays gas for every `execute` through its vault. With no trade of its own to
+ * measure from, a trade is assumed to cost this much gas (an assumption, reported as such).
+ */
+export declare const ASSUMED_EXECUTE_GAS = 350000n;
+/** Gas is low when it covers fewer trades than this. */
+export declare const LOW_GAS_TRADES = 20;
+export interface AgentGas {
+    /** The agent key's ETH balance, in wei (decimal string) and in ETH. */
+    balanceWei: string;
+    balanceEth: number;
+    low: boolean;
+    /** Trades the balance pays for at the gas price now; null when the price is unknown. */
+    estimatedTradesLeft: number | null;
+    /** Where the per-trade cost comes from: the agent's own recent trades, or the assumption. */
+    basis: "measured" | "assumed";
+    gasPerTrade: string;
+}
+export declare function agentGasStatus(input: {
+    balanceWei: bigint;
+    gasPriceWei: bigint | null;
+    /** Median gas used by the agent's own recent trades, when there are some. */
+    measuredGasPerTrade?: bigint | null;
+}): AgentGas;
+//# sourceMappingURL=notifications.d.ts.map

package/dist/notifications.js

@@ -0,0 +1,45 @@
+/**
+ * What Bonded tells an agent's owner about (webhook, optional email and the in-app list,
+ * `GET /self/notifications/inbox`). Each type can be turned off in the owner's settings
+ * (`muted`). Each event is sent once: its `dedupeKey` names it.
+ */
+export const NOTIFICATION_TYPES = {
+    rating_finished: "A rating or preview finished.",
+    rating_failed: "A rating or preview stopped.",
+    rating_refused: "A rating or preview was refused (not attested).",
+    score_expiring: "The agent's score expires in 7 days.",
+    runner_offline: "The runner has been offline for over 30 minutes while a rating or renewal is due.",
+    breach_recorded: "The vault recorded a breach.",
+    claim_filed: "A claim was filed for a breach.",
+    claim_paid: "A claim was paid.",
+    cover_lapsing: "The cover's premium is past due (in its grace period) or the cover lapsed.",
+    low_gas: "The agent key is low on gas.",
+};
+export const NOTIFICATION_TYPE_LIST = Object.keys(NOTIFICATION_TYPES);
+/** How long before a score's expiry the owner is told. */
+export const SCORE_EXPIRY_WARNING_SECONDS = 7 * 86_400;
+/** How long a runner may be away, while a rating or renewal is due, before the owner is told. */
+export const RUNNER_OFFLINE_ALERT_MS = 30 * 60_000;
+/**
+ * The agent key pays gas for every `execute` through its vault. With no trade of its own to
+ * measure from, a trade is assumed to cost this much gas (an assumption, reported as such).
+ */
+export const ASSUMED_EXECUTE_GAS = 350000n;
+/** Gas is low when it covers fewer trades than this. */
+export const LOW_GAS_TRADES = 20;
+export function agentGasStatus(input) {
+    const gas = input.measuredGasPerTrade && input.measuredGasPerTrade > 0n
+        ? input.measuredGasPerTrade
+        : ASSUMED_EXECUTE_GAS;
+    const perTrade = input.gasPriceWei !== null ? gas * input.gasPriceWei : null;
+    const left = perTrade && perTrade > 0n ? Number(input.balanceWei / perTrade) : null;
+    return {
+        balanceWei: input.balanceWei.toString(),
+        balanceEth: Number(input.balanceWei) / 1e18,
+        low: input.balanceWei === 0n || (left !== null && left < LOW_GAS_TRADES),
+        estimatedTradesLeft: left,
+        basis: input.measuredGasPerTrade && input.measuredGasPerTrade > 0n ? "measured" : "assumed",
+        gasPerTrade: gas.toString(),
+    };
+}
+//# sourceMappingURL=notifications.js.map

package/dist/observed-rates.d.ts

@@ -0,0 +1,125 @@
+import { type ClassGroup } from "./actuarial.js";
+/**
+ * Observed breach rates in production (docs/SPECIFICATION.md Section 9.1, "λ ... is updated from
+ * telemetry across the insured book"). The Arena measures b, the chance an agent breaches when it
+ * meets an attack; λ, how often agents meet attacks in a year, is a published prior. Production
+ * breaches recorded by vaults are the evidence that can replace the prior, and this module turns
+ * them into rates with their counts and exposure, so every number travels with its sample size.
+ *
+ * The method is actual against expected:
+ *
+ * - exposure: the agent-years during which rated agents held a valid score;
+ * - expected breaches in group g: Σ over that exposure of λ_g · b̄_g · years, where b̄_g is the
+ *   posterior mean breach rate from the agent's own rating, (k + 1) ÷ (n + 2);
+ * - observed breaches: the vault's breach log over the same exposure;
+ * - implied λ_g = prior λ_g · observed ÷ expected.
+ *
+ * A vault's breach record says which rule was broken, not which attack caused it, so most
+ * production breaches can't be put in a group. Those are counted as unattributed: they inform the
+ * book-wide ratio, never a group's λ. Pricing keeps the published priors until a group passes
+ * `OBSERVED_RATES_THRESHOLD` (see `pricingLambdas`).
+ */
+/**
+ * When an observed λ may replace a group's prior: at least this much exposure, and at least this
+ * many breaches attributed to the group. Ten events gives a 90% interval of roughly ±50% on a
+ * Poisson rate, which is about as wide as the gap between the priors themselves; below that, the
+ * prior is the better estimate. Both numbers are judgement, written here so they can be reviewed.
+ */
+export declare const OBSERVED_RATES_THRESHOLD: {
+    readonly minAgentYears: 25;
+    readonly minBreaches: 10;
+};
+/** One rated period of an agent: from a score's issue to its expiry or its replacement. */
+export interface ExposurePeriod {
+    agentId: string;
+    /** Unix seconds. */
+    from: number;
+    /** Unix seconds; the score's expiry. */
+    to: number;
+    /** The rating's per-group episodes and breaches (`Scoring.groups`), by group id. */
+    groups: Record<string, {
+        episodes: number;
+        breaches: number;
+    }>;
+}
+/** One breach a production vault recorded. */
+export interface ProductionBreach {
+    agentId: string;
+    /** Unix seconds. */
+    at: number;
+    /** The vault blocked it (Enforce mode). It still counts: the agent tried. */
+    blocked: boolean;
+    /** The attack group, when something attributes the breach to one (rare: see the module note). */
+    group?: string;
+}
+export interface GroupObservedRate {
+    id: string;
+    name: string;
+    /** The published prior (`CLASS_GROUPS`). */
+    priorLambda: number;
+    /** Breaches attributed to this group within exposure. */
+    breaches: number;
+    /** What the priors and the agents' own ratings predict over the same exposure. */
+    expectedBreaches: number;
+    /** Attributed breaches per agent-year (0 with no exposure). */
+    ratePerAgentYear: number;
+    /** 90% upper bound on that rate (Poisson); null with no exposure. */
+    rateUpper90: number | null;
+    /** prior × observed ÷ expected; null when nothing is expected. */
+    impliedLambda: number | null;
+    /** What pricing uses: the prior, until this group passes the threshold. */
+    pricingLambda: number;
+    usingObserved: boolean;
+}
+export interface ObservedRates {
+    exposure: {
+        agentYears: number;
+        agents: number;
+        periods: number;
+    };
+    breaches: {
+        /** Every breach given, in exposure or not. */
+        total: number;
+        /** Breaches while the agent held a valid score: the ones these rates use. */
+        inExposure: number;
+        /** Breaches by agents without a valid score at the time: not used. */
+        outsideExposure: number;
+        blocked: number;
+        attributed: number;
+        unattributed: number;
+    };
+    /** The whole book: every in-exposure breach against every group's expected breaches. */
+    overall: {
+        breaches: number;
+        expectedBreaches: number;
+        /** observed ÷ expected; null when nothing is expected. */
+        actualToExpected: number | null;
+        ratePerAgentYear: number;
+        rateUpper90: number | null;
+    };
+    groups: GroupObservedRate[];
+    threshold: typeof OBSERVED_RATES_THRESHOLD;
+    /** True when any group's pricing λ comes from observation. */
+    usingObserved: boolean;
+}
+/**
+ * Estimates observed breach rates from rated exposure and production breaches. Overlapping
+ * periods of one agent are cut where the newer score starts, so time is never counted twice.
+ * Periods and breaches after `now` are ignored.
+ */
+export declare function estimateObservedRates(input: {
+    periods: readonly ExposurePeriod[];
+    breaches: readonly ProductionBreach[];
+    /** Unix seconds. */
+    now: number;
+    groups?: readonly ClassGroup[];
+    threshold?: typeof OBSERVED_RATES_THRESHOLD;
+}): ObservedRates;
+/** The λ each group's pricing uses: the published prior unless observation passed the threshold. */
+export declare function pricingLambdas(rates: ObservedRates): Record<string, number>;
+/**
+ * Upper bound on a Poisson mean after observing k events: the μ at which P(X ≤ k) = 1 − level.
+ * Solved by bisection on the exact CDF.
+ */
+export declare function poissonUpperBound(k: number, level?: number): number;
+//# sourceMappingURL=observed-rates.d.ts.map

package/dist/observed-rates.js

@@ -0,0 +1,158 @@
+import { CLASS_GROUPS } from "./actuarial.js";
+/**
+ * Observed breach rates in production (docs/SPECIFICATION.md Section 9.1, "λ ... is updated from
+ * telemetry across the insured book"). The Arena measures b, the chance an agent breaches when it
+ * meets an attack; λ, how often agents meet attacks in a year, is a published prior. Production
+ * breaches recorded by vaults are the evidence that can replace the prior, and this module turns
+ * them into rates with their counts and exposure, so every number travels with its sample size.
+ *
+ * The method is actual against expected:
+ *
+ * - exposure: the agent-years during which rated agents held a valid score;
+ * - expected breaches in group g: Σ over that exposure of λ_g · b̄_g · years, where b̄_g is the
+ *   posterior mean breach rate from the agent's own rating, (k + 1) ÷ (n + 2);
+ * - observed breaches: the vault's breach log over the same exposure;
+ * - implied λ_g = prior λ_g · observed ÷ expected.
+ *
+ * A vault's breach record says which rule was broken, not which attack caused it, so most
+ * production breaches can't be put in a group. Those are counted as unattributed: they inform the
+ * book-wide ratio, never a group's λ. Pricing keeps the published priors until a group passes
+ * `OBSERVED_RATES_THRESHOLD` (see `pricingLambdas`).
+ */
+/**
+ * When an observed λ may replace a group's prior: at least this much exposure, and at least this
+ * many breaches attributed to the group. Ten events gives a 90% interval of roughly ±50% on a
+ * Poisson rate, which is about as wide as the gap between the priors themselves; below that, the
+ * prior is the better estimate. Both numbers are judgement, written here so they can be reviewed.
+ */
+export const OBSERVED_RATES_THRESHOLD = { minAgentYears: 25, minBreaches: 10 };
+const YEAR_SECONDS = 365.25 * 86_400;
+/**
+ * Estimates observed breach rates from rated exposure and production breaches. Overlapping
+ * periods of one agent are cut where the newer score starts, so time is never counted twice.
+ * Periods and breaches after `now` are ignored.
+ */
+export function estimateObservedRates(input) {
+    const groups = input.groups ?? CLASS_GROUPS;
+    const threshold = input.threshold ?? OBSERVED_RATES_THRESHOLD;
+    const byAgent = new Map();
+    for (const p of input.periods) {
+        const list = byAgent.get(p.agentId) ?? [];
+        list.push(p);
+        byAgent.set(p.agentId, list);
+    }
+    // Each agent's periods, in order, each ending where the next starts (a newer score replaces
+    // the older one) and none past now.
+    const periods = [];
+    for (const list of byAgent.values()) {
+        list.sort((a, b) => a.from - b.from);
+        list.forEach((p, i) => {
+            const next = list[i + 1];
+            const to = Math.min(p.to, next ? next.from : Infinity, input.now);
+            if (to > p.from)
+                periods.push({ ...p, to });
+        });
+    }
+    const years = (p) => (p.to - p.from) / YEAR_SECONDS;
+    const agentYears = sum(periods.map(years));
+    const expected = new Map(groups.map((g) => [
+        g.id,
+        sum(periods.map((p) => {
+            const r = p.groups[g.id] ?? { episodes: 0, breaches: 0 };
+            return g.lambda * ((r.breaches + 1) / (r.episodes + 2)) * years(p);
+        })),
+    ]));
+    const covered = (b) => b.at <= input.now &&
+        periods.some((p) => p.agentId === b.agentId && b.at >= p.from && b.at < p.to);
+    const counted = input.breaches.filter(covered);
+    const known = new Set(groups.map((g) => g.id));
+    const attributed = counted.filter((b) => b.group !== undefined && known.has(b.group));
+    const rows = groups.map((g) => {
+        const breaches = attributed.filter((b) => b.group === g.id).length;
+        const exp = expected.get(g.id) ?? 0;
+        const impliedLambda = exp > 0 ? (g.lambda * breaches) / exp : null;
+        const usingObserved = impliedLambda !== null &&
+            agentYears >= threshold.minAgentYears &&
+            breaches >= threshold.minBreaches;
+        return {
+            id: g.id,
+            name: g.name,
+            priorLambda: g.lambda,
+            breaches,
+            expectedBreaches: exp,
+            ratePerAgentYear: agentYears > 0 ? breaches / agentYears : 0,
+            rateUpper90: agentYears > 0 ? poissonUpperBound(breaches) / agentYears : null,
+            impliedLambda,
+            pricingLambda: usingObserved ? impliedLambda : g.lambda,
+            usingObserved,
+        };
+    });
+    const expectedTotal = sum([...expected.values()]);
+    return {
+        exposure: {
+            agentYears,
+            agents: new Set(periods.map((p) => p.agentId)).size,
+            periods: periods.length,
+        },
+        breaches: {
+            total: input.breaches.length,
+            inExposure: counted.length,
+            outsideExposure: input.breaches.length - counted.length,
+            blocked: counted.filter((b) => b.blocked).length,
+            attributed: attributed.length,
+            unattributed: counted.length - attributed.length,
+        },
+        overall: {
+            breaches: counted.length,
+            expectedBreaches: expectedTotal,
+            actualToExpected: expectedTotal > 0 ? counted.length / expectedTotal : null,
+            ratePerAgentYear: agentYears > 0 ? counted.length / agentYears : 0,
+            rateUpper90: agentYears > 0 ? poissonUpperBound(counted.length) / agentYears : null,
+        },
+        groups: rows,
+        threshold,
+        usingObserved: rows.some((r) => r.usingObserved),
+    };
+}
+/** The λ each group's pricing uses: the published prior unless observation passed the threshold. */
+export function pricingLambdas(rates) {
+    return Object.fromEntries(rates.groups.map((g) => [g.id, g.pricingLambda]));
+}
+/**
+ * Upper bound on a Poisson mean after observing k events: the μ at which P(X ≤ k) = 1 − level.
+ * Solved by bisection on the exact CDF.
+ */
+export function poissonUpperBound(k, level = 0.9) {
+    if (!Number.isInteger(k) || k < 0)
+        throw new RangeError(`need an integer k >= 0, got ${k}`);
+    if (!(level > 0 && level < 1))
+        throw new RangeError(`level must be in (0, 1), got ${level}`);
+    let lo = 0;
+    let hi = Math.max(10, 4 * (k + 1));
+    while (poissonCdf(k, hi) > 1 - level)
+        hi *= 2;
+    for (let i = 0; i < 80; i++) {
+        const mid = (lo + hi) / 2;
+        if (poissonCdf(k, mid) > 1 - level)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    return (lo + hi) / 2;
+}
+/** P(X ≤ k) for X ~ Poisson(mu), summed in log space so a large mu doesn't underflow. */
+function poissonCdf(k, mu) {
+    if (mu <= 0)
+        return 1;
+    let logTerm = -mu;
+    let total = Math.exp(logTerm);
+    for (let i = 1; i <= k; i++) {
+        logTerm += Math.log(mu) - Math.log(i);
+        total += Math.exp(logTerm);
+    }
+    return Math.min(1, total);
+}
+function sum(values) {
+    return values.reduce((total, v) => total + v, 0);
+}
+//# sourceMappingURL=observed-rates.js.map

package/dist/problems.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Every problem, warning and refusal a builder can see, with a stable `code`, the sentence (or the
+ * gist of it, when the real one carries numbers or times) and what to do about it. The API puts
+ * the code next to each sentence (`code` beside `error`, `issues[].code` beside check problems,
+ * `problems[].code` in the health panel), the web app links each message to its entry on the
+ * troubleshooting page by code (`#<code>`), and the docs page is built from `PROBLEMS`.
+ *
+ * Codes never change once published: a new message gets a new entry. `match` is how a sentence
+ * the services already produce is recognised, so codes don't depend on every call site.
+ */
+export type ProblemArea = "sign-in" | "requests" | "registration" | "connection" | "check" | "rating" | "cover" | "vault" | "notifications" | "service";
+export interface ProblemEntry {
+    code: string;
+    area: ProblemArea;
+    /** The message, or its gist when the real one carries numbers, ids or times. */
+    sentence: string;
+    /** What to do about it, in plain words. */
+    fix: string;
+    /** How the sentences the services produce are recognised. The first entry that matches wins. */
+    match: readonly RegExp[];
+}
+/** The catch-all for a sentence no entry recognises (it still has its own words). */
+export declare const UNKNOWN_PROBLEM = "other";
+/** Ordered: specific entries before general ones. */
+export declare const PROBLEMS: readonly ProblemEntry[];
+/** The stable code for a sentence (`UNKNOWN_PROBLEM` when no entry recognises it). */
+export declare function problemCode(sentence: string): string;
+/** A sentence with its code and fix, as the API returns problems. */
+export interface CodedProblem {
+    code: string;
+    text: string;
+    fix?: string;
+}
+export declare function codedProblem(text: string, code?: string): CodedProblem;
+/** The entry for a code, if there is one. */
+export declare function problemEntry(code: string): ProblemEntry | undefined;
+/** The troubleshooting list for the docs page: code, sentence and fix, without the matchers. */
+export declare function troubleshootingList(): {
+    code: string;
+    area: ProblemArea;
+    sentence: string;
+    fix: string;
+}[];
+//# sourceMappingURL=problems.d.ts.map