@descryy/core 0.3.0 → 0.5.0

package/dist/tiers/certify.d.ts

@@ -1,170 +1,41 @@
 /**
- * The capability-tier generator. DEC-075 §6, in code.
- *
- * > *"A tier is generated from `capabilities()`, never written in prose, and may
- * > be published for a language only when the corpus passes at the resolution
- * > the tier claims, a ≥200-edge precision draw passes on at least two
- * > repositories the adapter's author did not choose, and `capabilities()`
- * > declares exactly the node and edge types the adapter emitted."*
- *
- * ## The design point: this thing exists to say no
- *
- * A generator that awards a tier to everything it is shown is a rubber stamp
- * with a build step. The output that matters is **the row that failed**, which
- * is why `unmet` is a list of requirements with their statements rather than a
- * boolean, and why `certify` never returns a bare tier without also returning
- * what the next tier up is missing.
- *
- * Two rules follow from that, and both are the opposite of what is convenient:
- *
- * 1. **Absent evidence is not a pass.** No precision draw recorded means the
- *    attested requirement is unmet, exactly as if a recorded draw had failed.
- *    The alternative — treating silence as satisfaction — is how every unearned
- *    claim in this repository would have been generated.
- * 2. **An attested requirement is labelled attested, in the output, always.**
- *    A machine can check "≥200 edges" and "two repositories". It cannot check
- *    *"the author did not choose them"*, because that is a fact about a person's
- *    intent. Marking it as declared-by-a-human is what stops this function
- *    laundering a judgement into a computed result. `certify` therefore reports
- *    `attestedBy` alongside the tier, and a consumer that prints the tier
- *    without it has dropped the only part that says who is responsible.
- *
- * ## What it does not do
- *
- * It does not run the conformance harness or the precision benches. It is given
- * their results. That keeps it pure and testable, and it keeps the awkward fact
- * visible: the precision evidence is **recorded by hand today**, because the
- * benches are throwaway scripts that print to a terminal. `GateEvidence` is
- * where that hand-recording is written down and dated, rather than living in a
- * decision document that nothing reads.
+ * Capability-tier generator (DEC-075 §6): computed from `capabilities()`, never prose. Requires a
+ * ≥200-edge precision draw on two repos the author didn't choose; absent evidence fails, never passes.
+ * Given harness/bench results, doesn't run them itself; `attestedBy` names who recorded the human call.
  */
 import type { CapabilityMatrix, EdgeType, NodeType, ResolutionLevel } from "@descryy/ir";
 import type { RefusalCensus } from "../query/unresolved.ts";
 import { type Requirement, type Tier } from "./ladder.ts";
-/**
- * One adjudicated precision draw, as DEC-075 §6.2 requires it.
- *
- * `authorChose` is the field that makes this honest. It defaults to nothing —
- * a recorder who has not thought about it produces an incomplete record rather
- * than an accidental pass, the same reason `reliabilityCap`'s `nameLevel` has
- * no default.
- */
+/** One adjudicated precision draw (DEC-075 §6.2). `authorChose` has no default — an unrecorded
+ *  value is an incomplete record, not an accidental pass (same reason as `reliabilityCap.nameLevel`). */
 export interface PrecisionDraw {
     readonly repository: string;
     readonly edgeType: EdgeType | "mixed";
     readonly drawn: number;
     readonly correct: number;
-    /**
-     * How many of `drawn` the adjudicator actually rendered a verdict on —
-     * `undefined` when every adjudicator this project has ever recorded a draw
-     * with decides every row it draws, so `decided` and `drawn` have always
-     * been the same number and no draw needed to say so until now.
-     *
-     * **Kotlin is the first adapter where they diverge, and the divergence
-     * exposed a real instrument defect.** `correct / drawn` silently punishes
-     * an adjudicator for honestly declining to decide a row exactly as if it
-     * had decided that row wrong — okhttp drew 200, decided 192, and every one
-     * of the 192 it *did* decide was correct (192/192 = 100%, its own
-     * pre-registered gate: GATE PASSED); `correct / drawn` reads that as
-     * 192/200 = 96%, below the 98% floor, for a reason that has nothing to do
-     * with the adapter's precision. Precision is measured over `decided` rows
-     * only (see `checkPrecisionDraws`); `decided / drawn` — coverage — is a
-     * separate, always-disclosed axis (`bench/tier-matrix.mjs`'s
-     * `describeDrawCoverage`), never folded into the precision figure: a draw
-     * with high coverage and lower precision and one with low coverage and
-     * clean precision are different facts, and burying the second inside a
-     * clean-looking percentage is the failure this field exists to prevent.
-     */
+    /** How many of `drawn` rows the adjudicator actually decided (undefined if it never diverges).
+     *  Precision = correct/decided, not correct/drawn — okhttp: 192/192 decided passes 98%, but
+     *  192/200 fails it for the wrong reason. Coverage (decided/drawn) is disclosed separately. */
     readonly decided?: number;
-    /**
-     * How many candidates of this edge type the repository contained — the
-     * population the draw was taken **from**, not the sample size.
-     *
-     * ## Zero out of zero is undefined here too
-     *
-     * Without it, `0 edges drawn, below 200` and `47 edges drawn, below 200` print
-     * identically, and they are different facts with different remedies:
-     *
-     * | | statement about | what to do |
-     * | --- | --- | --- |
-     * | population 0 | **the corpus** — this reference set contains nothing to sample | find other repositories, or accept the bar is unreachable here |
-     * | population > 0, drawn short | **the adapter** — measured and short | measure more |
-     *
-     * Python is the live case: `USES_API` is emitted and measures **0 edges** on
-     * both reference repositories, and that zero is *correct* — a backend service
-     * in this reference set is a provider rather than a consumer, so no 200-edge
-     * draw is reachable from it at all. Reporting that as "below 200" tells a
-     * reader to measure harder, when the honest answer is that **this reference
-     * set cannot answer the question**.
-     *
-     * `undefined` means the population was not recorded, which is neither zero nor
-     * non-zero and is reported as its own case — the same reason
-     * `capabilitiesHonest` has an `"unknown"`.
-     */
+    /** Population this edge type could draw from (not the sample size). Needed because 0-of-0 and
+     *  0-of-200 are different facts: Python's USES_API measures 0 because backends are providers only
+     *  here — that's a fact about the corpus, not the adapter. `undefined` = not recorded, its own case. */
     readonly population?: number;
-    /**
-     * The refusal census for this draw's edge type, from `classifyRefusals`.
-     *
-     * ## Why the census rather than a recorded "drawable" count
-     *
-     * The number that decides reachability is **population minus `outOfScope`**:
-     * a call read correctly that targets something this workspace does not serve
-     * can never become an edge here, however good the adapter gets.
-     *
-     * | | population | outOfScope | drawable | reads as |
-     * | --- | --- | --- | --- | --- |
-     * | `saleor` | 0 | 0 | **0** | nothing to sample |
-     * | `dispatch` | 4 | 4 | **0** | four third-party calls, refused forever |
-     * | `discourse` | 20 | 0 | **20** | a capability gap the adapter owns |
-     *
-     * Carrying the census rather than a recorded count keeps this **derived**, so
-     * a measured zero still attests to itself and needs no attribution — unlike a
-     * `StructuralLimit`. And it cannot drift from the ledger, **because it is the
-     * ledger**: a separately recorded "drawable" number is the same fact in two
-     * places, and this project has measured what that costs.
-     *
-     * ## The abuse route, which is why `scopeKnown` is load-bearing
-     *
-     * With no internal hosts supplied, `classifyRefusals` classifies **every**
-     * absolute target as `outOfScope` and says so — it "understates the deficit".
-     * Subtracting blindly there would let an adapter that declares no hosts write
-     * off every external-looking call as unreachable and **improve its tier by
-     * supplying less information**. So `scopeKnown === false` makes the
-     * subtraction **unavailable**, never zero.
-     *
-     * Absent entirely, `drawable` falls back to the full population — which blames
-     * the **adapter** rather than the corpus. That is the safe direction: the
-     * failure being guarded is a tier improved by withholding evidence.
-     */
+    /** Refusal census for this edge type. drawable = population − outOfScope (a call that can never
+     *  target this workspace can never become an edge here). `scopeKnown === false` makes that
+     *  subtraction unavailable, never zero — blocks gaming the tier by declaring fewer hosts. */
     readonly refusals?: RefusalCensus;
     /** The negative control over the same adjudicator. Must be ~0. */
     readonly controlDrawn: number;
     readonly controlCorrect: number;
-    /**
-     * Did the adapter's author pick this repository? DEC-075 §6.2 requires two
-     * where the answer is **no**. Declared, never inferred — see the header.
-     */
+    /** Did the adapter's author pick this repo? DEC-075 §6.2 requires two that didn't. Declared, not inferred. */
     readonly authorChose: boolean;
     /** Who recorded this, so an attested claim has a name against it. */
     readonly recordedBy: string;
     readonly recordedOn: string;
-    /**
-     * The mixed draw's own composition, by edge type — `undefined` for every
-     * draw recorded before this field existed, and that absence is itself
-     * meaningful (see `checkCapability`'s use of it: no data means the
-     * type-floor check does not run for that draw, not that it fails).
-     *
-     * The gap this closes: DEC-221 made the precision draw whole-graph and
-     * NOT edge-type-scoped (a `USES_API`-only draw structurally cannot carry
-     * a negative control, DEC-164 §2). That is still correct for what a
-     * *draw* needs to qualify. But a language's tier can rest on a capability
-     * (`A.callers` on `USES_API`, `A.routes` on `SERVES_API`) that the draw
-     * happened to sample almost none of — Kotlin's ktor draw cleared 98%
-     * precision overall while carrying exactly one decided `USES_API` row,
-     * which is evidence of nothing about that specific capability. This field
-     * is what lets `checkCapability` tell "the capability was validated" from
-     * "the capability was declared and the aggregate draw happened to pass".
-     */
+    /** Per-edge-type breakdown within a mixed draw; undefined predates this field (no-op, not fail).
+     *  DEC-221 keeps draws whole-graph, not edge-scoped — Kotlin's ktor draw hit 98% precision overall
+     *  on exactly one decided USES_API row, which validates nothing about that capability specifically. */
     readonly perEdgeType?: Readonly<Record<string, {
         readonly decided: number;
         readonly correct: number;
@@ -173,17 +44,9 @@ export interface PrecisionDraw {
 export interface ConformanceEvidence {
     readonly resolution: ResolutionLevel;
     readonly passed: boolean;
-    /**
-     * DEC-070's **adapter** verdict — no type emitted that `capabilities()` did
-     * not declare.
-     *
-     * Deliberately not "the manifest check produced no findings". That check
-     * reports two different things and only one of them is the adapter's fault:
-     * `adapterFailed` (emitted-but-undeclared, a real overclaim) and `corpusThin`
-     * (declared-but-unexercised, a fact about the corpus). Reading them as one
-     * failed every adapter in the repository at Tier C on its first run here,
-     * because a low-resolution sweep leaves plenty declared and unexercised.
-     */
+    /** DEC-070's adapter verdict: no type emitted that `capabilities()` didn't declare. Distinguishes
+     *  `adapterFailed` (overclaim, the adapter's fault) from `corpusThin` (declared-unexercised, the
+     *  corpus's fault) — conflating them failed every adapter at Tier C on a low-resolution sweep. */
     readonly manifestClean: boolean;
 }
 export interface GateEvidence {
@@ -195,50 +58,15 @@ export interface GateEvidence {
     readonly emittedEdgeTypes?: readonly EdgeType[];
     readonly conformance: readonly ConformanceEvidence[];
     readonly precisionDraws: readonly PrecisionDraw[];
-    /**
-     * Types the adapter declares that **no corpus pattern exercised**.
-     *
-     * `checkManifest` already computes this and calls it `unpublishable`, with
-     * the comment *"not publishable as a tier claim"* — written before any tier
-     * generator existed. It is exactly right: a declared type nothing exercised
-     * is an untested claim, and a tier resting on it rests on a promise. Treated
-     * here as not satisfying a capability requirement at all, with its own reason
-     * so it is distinguishable from a type that was never declared.
-     */
+    /** Types declared but no corpus pattern exercised (`checkManifest`'s `unpublishable`). Treated as
+     *  not satisfying the requirement at all, with its own reason distinct from "never declared". */
     readonly unpublishableTypes?: readonly string[];
-    /**
-     * Capabilities that **cannot exist in this language**, whatever anyone builds.
-     *
-     * DEC-123's case: `REQUIRED_NOT_DECLARED` fires only when an environment
-     * accessor *fails* on absence, and JavaScript has no such form — `process.env.X`
-     * yields undefined. No adapter effort makes that finding reachable in
-     * TypeScript. Without this, the generator scores it as **absent evidence**,
-     * which is the verdict for *"nobody has built it yet"*, and the two collapse
-     * into one output.
-     *
-     * That collapse is the one distinction §20.2 exists to hold: *"we found
-     * nothing"* and *"we cannot check this"* are different sentences. At the tier
-     * layer the difference is between a gap someone should close and a boundary
-     * nobody can.
-     *
-     * **A limit does not block the tier, and it does not vanish either.** It is
-     * carried onto the certificate and printed, so the tier is published *with*
-     * its qualifier. Awarding the tier silently would claim the capability;
-     * withholding it forever would punish a language for its own semantics.
-     *
-     * `id` matches a requirement id (`A.callers`) or names a check
-     * (`REQUIRED_NOT_DECLARED`). `declaredBy` is required for the same reason
-     * `PrecisionDraw.recordedBy` is: **this is a human judgement, and an
-     * unattributable one is a way to dodge a requirement that is merely unbuilt.**
-     * A limit with no reason or no declarer is ignored, and the requirement is
-     * checked normally.
-     */
+    /** Capabilities this language cannot have, ever (DEC-123: REQUIRED_NOT_DECLARED needs an accessor
+     *  that fails on absence; JS has none). Distinct from "not built yet" (§20.2) — doesn't block the
+     *  tier and doesn't vanish, it's printed on the certificate. `declaredBy` required; unattributed = ignored. */
     readonly structuralLimits?: readonly StructuralLimit[];
-    /**
-     * Capabilities claimed **below** what the evidence supports, pending an open
-     * policy. See `PolicyCap` — this neither waives a requirement nor blocks a
-     * tier; it stops a deliberate cap being published as an absence.
-     */
+    /** Capabilities claimed below what evidence supports, pending an open policy (see `PolicyCap`).
+     *  Doesn't waive a requirement or block a tier — stops a deliberate cap being published as an absence. */
     readonly policyCaps?: readonly PolicyCap[];
 }
 /** A capability this language cannot have. Declared, never inferred. */
@@ -250,41 +78,9 @@ export interface StructuralLimit {
     /** Who declared it. An anonymous structural limit is not admissible. */
     readonly declaredBy: string;
 }
-/**
- * A capability we **could** claim higher and are deliberately claiming lower,
- * pending a policy that has not been written.
- *
- * ## The third state, and why two were not enough
- *
- * The certificate could say two things about a capability it does not claim:
- *
- * | | meaning |
- * | --- | --- |
- * | **absent** | we have not measured it |
- * | **unreachable** (`StructuralLimit`) | this language structurally cannot produce it |
- * | **capped** *(this)* | we could claim more and are choosing not to, pending a policy |
- *
- * Publishing the third as the first **understates a capability we have** — the
- * tier layer would tell a user we cannot do something we deliberately declined
- * to claim. That is §20.2's distinction one layer up, and the same family as the
- * `FILE` gap: two different sentences collapsing into one because there was only
- * one field to put them in.
- *
- * The case that produced it: an introspection-fed route table is R4 on fidelity
- * — it is read from a running process — and is claimed at R3 because R4's
- * promotion and expiry policy is open, R4 requires `observedByRun`, and R4 is
- * unconditionally class A (DEC-115). Nothing is lost, because R3 already reaches
- * class A for a name-level fact; what is lost is the *promise about expiry*, and
- * that is exactly what wants recording.
- *
- * ## It does not waive anything
- *
- * Unlike a `StructuralLimit`, a cap is **not** removed from the tier check. The
- * requirement is met at the lower claim, so there is nothing to waive — and that
- * asymmetry is deliberate: if a cap could skip a requirement it would become the
- * cheapest way to collect a tier, which is the abuse `admissibleLimits` already
- * guards against for the other kind.
- */
+/** A capability claimable higher but deliberately claimed lower, pending an unwritten policy —
+ *  distinct from absent (unmeasured) and StructuralLimit (impossible). E.g. an R4-introspected
+ *  route table claimed at R3 pending R4's expiry policy (R4 is unconditionally class A, DEC-115). */
 export interface PolicyCap {
     /** A requirement id, or the name of a check. */
     readonly id: string;
@@ -292,13 +88,8 @@ export interface PolicyCap {
     readonly claimable: string;
     /** What is actually claimed. */
     readonly claimed: string;
-    /**
-     * The open policy that would lift the cap.
-     *
-     * **Required, and a cap without one is ignored.** "Capped pending nothing" is
-     * not a cap, it is a decision — and a cap that names no condition can never be
-     * discharged, so it would sit on the certificate forever looking like caution.
-     */
+    /** The policy that would lift this cap. Required — a cap with none can never be discharged
+     *  and would sit on the certificate forever looking like caution rather than a decision. */
     readonly pendingOn: string;
     /** Who declared it. Same rule as `StructuralLimit`: unattributable is not admissible. */
     readonly declaredBy: string;
@@ -323,53 +114,27 @@ export interface TierCertificate {
     readonly unmetForNext: readonly UnmetRequirement[];
     /** Every tier's verdict, so a reader can see the whole ladder at once. */
     readonly byTier: Readonly<Record<Tier, readonly UnmetRequirement[]>>;
-    /**
-     * Names of the people whose declarations this tier rests on. Empty when the
-     * tier needed no attested requirement — C and B do not.
-     */
+    /** Who declared the attested requirements this tier rests on. Empty when the tier needs
+     *  none — C and B never do. */
     readonly attestedBy: readonly string[];
-    /**
-     * Edge types the qualifying precision draws actually covered. Empty under
-     * the same condition as `attestedBy`. See the generator's own comment: a
-     * tier resting on, say, an `IMPORTS`-only draw has not had `USES_API`
-     * itself sampled, and this is where a reader finds that out rather than
-     * assuming "Tier A" answered a question it did not.
-     */
+    /** Edge types the qualifying draws actually covered (empty under the same condition as
+     *  `attestedBy`). An IMPORTS-only draw doesn't mean USES_API was itself sampled — this
+     *  is where a reader finds that gap instead of assuming "Tier A" covers everything. */
     readonly attestedEdgeTypes: readonly (EdgeType | "mixed")[];
-    /**
-     * Requirements waived because this language cannot satisfy them, and checks
-     * declared unreachable. **Never empty-by-omission in the printed form** — a
-     * consumer that prints the tier without these has published a capability
-     * claim the certificate does not make.
-     */
+    /** Requirements waived as unreachable in this language. Never omit these when printing the
+     *  tier — a consumer that does has published a capability claim the certificate doesn't make. */
     readonly limitations: readonly StructuralLimit[];
-    /**
-     * Deliberate under-claims, printed for the same reason `limitations` are:
-     * omitting them publishes a cap as an absence, which understates a capability
-     * the adapter has.
-     */
+    /** Deliberate under-claims. Omitting them publishes a cap as an absence, understating a
+     *  capability the adapter actually has. */
     readonly policyCaps: readonly PolicyCap[];
-    /**
-     * Bars this **reference set** cannot answer — every recorded draw whose
-     * population was zero.
-     *
-     * Printed beside the structural limitations because it is the same kind of
-     * statement: not *"the adapter fell short"* but *"there was nothing here to
-     * measure"*. The remedy is other repositories, and a certificate that does not
-     * say so sends a reader to measure harder against an empty population.
-     */
+    /** Draws whose population was zero — nothing here to measure, not "the adapter fell short."
+     *  Printed beside structural limitations; the remedy is other repositories. */
     readonly unreachableHere: readonly EmptyPopulation[];
     /** DEC-075 §6.3: does `capabilities()` match what was emitted? */
     readonly capabilitiesHonest: boolean | "unknown";
 }
 export declare function certify(evidence: GateEvidence): TierCertificate;
-/**
- * The certificate as a developer should read it: the tier, then immediately the
- * reason it is not higher.
- *
- * The failing rows are not an appendix. A support matrix that prints "B" and
- * stops teaches a reader that B is the ceiling; printing what A is missing
- * turns the same fact into a work item.
- */
+/** Tier first, then immediately why it isn't higher. Printing "B" alone teaches a reader B is
+ *  the ceiling; printing what A is missing turns it into a work item instead. */
 export declare function formatCertificate(certificate: TierCertificate): string;
 //# sourceMappingURL=certify.d.ts.map

package/dist/tiers/certify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"certify.d.ts","sourceRoot":"","sources":["../../src/tiers/certify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAU,KAAK,WAAW,EAAE,KAAK,IAAI,EAA0B,MAAM,aAAa,CAAC;AAM1F;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;CACzG;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IAChD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IAChD,QAAQ,CAAC,WAAW,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACrD,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;IAClD;;;;;;;;;OASG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IACvD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CAC5C;AAED,wEAAwE;AACxE,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,SAAS;IACxB,gDAAgD;IAChD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAMD,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACnD,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,gBAAgB,EAAE,CAAC,CAAC,CAAC;IACrE;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,EAAE,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,EAAE,CAAC;IAC5D;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACjD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,eAAe,EAAE,CAAC;IACrD,kEAAkE;IAClE,QAAQ,CAAC,kBAAkB,EAAE,OAAO,GAAG,SAAS,CAAC;CAClD;AAuVD,wBAAgB,OAAO,CAAC,QAAQ,EAAE,YAAY,GAAG,eAAe,CA6E/D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,eAAe,GAAG,MAAM,CA+CtE"}
+{"version":3,"file":"certify.d.ts","sourceRoot":"","sources":["../../src/tiers/certify.ts"],"names":[],"mappings":"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"}