urtext 0.1.0

package/dist/score/reconcile.js

@@ -0,0 +1,208 @@
+import { minPossibleAnalyzerScore, rankWithAbsorption, tierFor } from "./index.js";
+import { referenceCount } from "./reach.js";
+/**
+ * Strictly below `minPossibleAnalyzerScore()` (currently 6, an
+ * `effect_removed` timing effect) — never the raw `WEIGHTS.factKind`
+ * minimum, which ignores the effect multiplier `scoreFact` applies and put
+ * the old hardcoded ceiling (14) 8 points above a score an analyzer can
+ * actually produce. Derived, not hand-copied, so a future weight change can
+ * only move this number, never leave it stale above a fact it is supposed
+ * to sit under.
+ */
+export const MODEL_CEILING = minPossibleAnalyzerScore() / 2;
+/**
+ * The model's severity, defensively bounded to the 0..1 range its type
+ * documents but does not enforce. `reconcile` is the trust boundary between
+ * unbelieved model output and a believed finding, so it must not assume the
+ * model behaved: an out-of-range value here is not hypothetical malice, just
+ * an unvalidated float from a network response. Unclamped, a `NaN`
+ * `severity` would produce a `NaN` score, and `NaN` compares false against
+ * everything, so the final sort would stop being a sort for every finding it
+ * touches — and an out-of-range value would let the model assign itself a
+ * ceiling `reconcile` never agreed to.
+ */
+function clampSeverity(severity) {
+    if (!Number.isFinite(severity))
+        return 0;
+    return Math.min(Math.max(severity, 0), 1);
+}
+/**
+ * The fewest references at which an unabsorbed blast_radius finding that no
+ * claim explains still earns a standalone row. "X changed and is referenced
+ * in one place" names no problem and barely any cost — a sixth of the first
+ * real dogfood report was exactly that row.
+ *
+ * Enforced here, after model claims attach, and not in `foldReach` where
+ * the fact-level fold happens: a claim citing the fact can only attach to a
+ * finding that still exists, so filtering earlier silently dropped the
+ * claim — the one kind of loss this pipeline is built to refuse. A finding
+ * a claim did attach to survives at its normal `inferred` tier, because
+ * model context is exactly what promotes the row out of "filler". Only the
+ * claim-free standalone row disappears: absorption into siblings happened
+ * back in `foldReach`, before any of this, so amplified findings are
+ * untouched, and the reach entry itself is recorded regardless.
+ * `test/score/reconcile.test.ts` pins the survival edge and both sides of
+ * the numeric line, so moving this number either way fails a test.
+ */
+export const MIN_STANDALONE_REFERENCES = 2;
+/**
+ * True for the rows `MIN_STANDALONE_REFERENCES` suppresses: a finding that
+ * is still a bare blast_radius fact's own row (grouping never produces one
+ * and absorption never lets one survive to here), below the threshold, with
+ * no claim attached. The fact lookup uses the finding id because an
+ * unabsorbed fact's finding keeps its fact's id — anything synthesized
+ * (groups, standalone claims) misses the map and is kept.
+ */
+function isSuppressedStandaloneReach(finding, byId) {
+    if (finding.claim)
+        return false;
+    const fact = byId.get(finding.id);
+    if (!fact || fact.kind !== "blast_radius")
+        return false;
+    return referenceCount(fact) < MIN_STANDALONE_REFERENCES;
+}
+/**
+ * Merges what the analyzers found with what the model said.
+ *
+ * The asymmetry is the point: a claim can only ever annotate a fact or
+ * stand alone, and a fact survives as a finding whether or not the model
+ * mentions it — with exactly one scoped exception, a claim-free lonely
+ * blast_radius row under MIN_STANDALONE_REFERENCES, filtered after claims
+ * attach and disclosed through `onSuppressed` rather than dropped in
+ * silence. The rule is pinned by "keeps every fact except a claim-free
+ * sub-threshold reach row as a finding even when the model says nothing"
+ * and the exception by "suppresses a claim-free lonely one-reference reach
+ * finding", both in test/score/reconcile.test.ts.
+ *
+ * A claim never edits a fact's file, line, or evidence — if the model
+ * asserts a location, it is ignored in favour of the analyzer's, because
+ * the analyzer's came from the code.
+ *
+ * The marker on a claim travels to the finding it lands on and nothing else:
+ * `test/score/reconcile.test.ts`, "changes no score and no ordering, with the
+ * marker or without it".
+ */
+export function reconcile(facts, claims, 
+// Called with how many claims lost the first-claim-wins race below — a
+// later claim naming an already-explained finding is dropped, and the
+// reader cannot know the model said two things about it unless the caller
+// says so. Invoked only when the count is nonzero, so `review` in
+// `../cli.ts` can turn it into one warnings line without branching.
+onDroppedClaims, 
+// Called with how many claim-free standalone reach rows the
+// MIN_STANDALONE_REFERENCES filter removed. A row that vanishes from
+// every surface with no trace leaves even the machine-readable output
+// unable to say the filter ran at all — the same disclosure rule as
+// `onDroppedClaims` above, and the same contract: invoked only when the
+// count is nonzero.
+onSuppressed) {
+    const byId = new Map(facts.map((f) => [f.id, f]));
+    const { findings: ranked, absorbedBy } = rankWithAbsorption(facts);
+    // Indexed so a standalone finding's id can stay unique even when two
+    // claims share a model-generated `id` — a model's ids are not guaranteed
+    // unique the way a fact's are, so the array position backstops it.
+    const indexed = claims.map((claim, i) => ({ claim, i }));
+    // Every claim that names a real fact resolves to the id of the finding
+    // that fact's information ends up on — its own finding, ordinarily, but
+    // `absorbedBy` redirects to whichever finding absorbed it if `rank`
+    // folded it into a sibling's reach or a file's export group. The model is
+    // shown facts, not findings, so citing a fact that a machine step later
+    // merged away is expected behaviour, not a mistake — on a real range a
+    // large share of facts get folded this way.
+    //
+    // First claim wins when the target repeats, deterministically: claims are
+    // walked in the order they arrived, and once a target finding has an
+    // explanation, a later duplicate does not silently override it. This
+    // covers two distinct collisions with one rule — two claims naming the
+    // same fact, and two claims naming two different facts that both
+    // absorbed into the same finding.
+    const attachTo = new Map();
+    // Losers of the first-claim-wins race, counted so the drop is disclosed
+    // rather than silent. Dangling references are not in this count: they are
+    // dropped for a different, documented reason (below), and counting them
+    // here would present "the model named a fact that doesn't exist" as "the
+    // model said more about a finding".
+    let dropped = 0;
+    for (const entry of indexed) {
+        const { correspondsTo } = entry.claim;
+        // A `correspondsTo` naming no real fact is a dangling reference, not a
+        // claim to attach or recover — it is dropped further down by simply
+        // never being added here or to the standalone list.
+        if (!correspondsTo || !byId.has(correspondsTo))
+            continue;
+        const targetId = absorbedBy.get(correspondsTo) ?? correspondsTo;
+        if (!attachTo.has(targetId)) {
+            attachTo.set(targetId, { claim: entry.claim, factId: correspondsTo });
+        }
+        else {
+            dropped++;
+        }
+    }
+    if (dropped > 0)
+        onDroppedClaims?.(dropped);
+    const findings = ranked.map((finding) => {
+        const entry = attachTo.get(finding.id);
+        if (!entry)
+            return finding;
+        // `entry.factId` is `entry.claim.correspondsTo` by construction above,
+        // so this call is defensive, not a live discrimination: `tierFor` can
+        // only ever return `inferred` here. Going through the real function
+        // anyway, rather than hardcoding `"inferred"`, keeps this in lockstep
+        // with `tierFor`'s own definition of what makes a claim count as
+        // corresponding, instead of a second copy of that rule drifting apart
+        // from it. `fact` is always defined here: `attachTo` only ever stores a
+        // `factId` that passed `byId.has(...)` above, but a `Map.get` cannot
+        // carry that proof through its return type, so the guard stays as the
+        // narrowing it is rather than a `!` assertion claiming more certainty
+        // than the compiler has.
+        const fact = byId.get(entry.factId);
+        if (!fact)
+            return finding;
+        return {
+            ...finding,
+            tier: tierFor(fact, entry.claim),
+            claim: { summary: entry.claim.summary, reasoning: entry.claim.reasoning },
+            // The marker travels with the claim to wherever it attaches, including
+            // the attach-to-absorber path: one rule, not two — `attachTo` is
+            // already keyed by the finding the claim lands on, so the redirected
+            // claim arrives here like any other. Spread conditionally because the
+            // field is absent-or-true — there is no "not beyond intent" state to
+            // write.
+            ...(entry.claim.beyondIntent ? { beyondIntent: true } : {}),
+        };
+    });
+    // After the claims are on, not before — see MIN_STANDALONE_REFERENCES.
+    const kept = findings.filter((f) => !isSuppressedStandaloneReach(f, byId));
+    if (kept.length < findings.length)
+        onSuppressed?.(findings.length - kept.length);
+    // Only a claim with no `correspondsTo` at all stands alone. One that names
+    // a `correspondsTo` pointing at no real fact is a dangling reference, not
+    // a standalone observation — it is dropped rather than promoted, because
+    // treating "the model named a fact that doesn't exist" the same as "the
+    // model wasn't talking about a fact" would let a wrong id manufacture a
+    // finding out of nothing.
+    const standalone = indexed
+        .filter(({ claim }) => !claim.correspondsTo)
+        .map(({ claim, i }) => ({
+        id: `claim:${i}:${claim.id}`,
+        tier: "model",
+        file: claim.file,
+        line: claim.line,
+        title: claim.summary,
+        body: claim.reasoning,
+        // MODEL_CEILING already sits strictly below the weakest score an
+        // analyzer can produce, so a severity clamped to [0, 1] scales this
+        // linearly up to — at maximum severity, reaching, but by
+        // construction never crossing — that ceiling.
+        score: clampSeverity(claim.severity) * MODEL_CEILING,
+        evidence: [],
+        ...(claim.beyondIntent ? { beyondIntent: true } : {}),
+    }));
+    return [...kept, ...standalone].sort((a, b) => b.score - a.score ||
+        a.file.localeCompare(b.file) ||
+        a.line - b.line ||
+        // Final tiebreak so the sort is total: without it, findings tied on
+        // score/file/line fall back to array (insertion) order, which is an
+        // accident of iteration, not a guarantee.
+        a.id.localeCompare(b.id));
+}

package/dist/types.d.ts

@@ -0,0 +1,221 @@
+import type ts from "typescript";
+/** Sentinel revision: read files from the working tree rather than git. */
+export declare const WORKTREE = "WORKTREE";
+/**
+ * Directory, relative to the repository root, that urtext writes its own
+ * reports into. Lives here rather than in `report/write.ts` because
+ * `extract/diff.ts` needs it too — the untracked-file count has to leave
+ * urtext's own output out — and neither of those two modules should have to
+ * import the other to agree on the name.
+ */
+export declare const REPORT_DIR = ".urtext";
+export interface RevRange {
+    /** Revision to treat as "before". A commit-ish. */
+    from: string;
+    /** Revision to treat as "after". A commit-ish, or WORKTREE. */
+    to: string;
+    /** Human-readable description, e.g. "vs origin/main". */
+    label: string;
+}
+export interface Hunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+}
+export type SymbolKind = "function" | "method" | "class" | "type" | "enum" | "variable";
+export interface ChangedSymbol {
+    name: string;
+    /**
+     * Dotted path through every scope that encloses the declaration —
+     * "Gamma.method", "wrapper.local", "N.x" — and equal to `name` only for a
+     * declaration at the top level of the file. Identity is keyed on this, not
+     * on `name`: two classes in one file may each declare `render`, and a
+     * function's local may share a name with an export beside it. A scope with
+     * no name of its own contributes a sentinel rather than nothing (see
+     * `extract/scope.ts`), so this is qualified all the way up in every case.
+     */
+    qualifiedName: string;
+    kind: SymbolKind;
+    /**
+     * Carries an `export` modifier at the top level of the file. Deliberately not
+     * phrased as "is part of the file's public surface", because it is narrower
+     * than that: a declaration exported by a separate statement — `function
+     * helper() {}` plus `export { helper }` — has no modifier of its own, comes
+     * out `false`, and so gets no blast radius and no row in the report's
+     * API-surface table. That table lists the omission rather than implying it
+     * covers everything. A namespace member is `false` too, and that one is
+     * right: an importer reaches it through the namespace, not by its bare name,
+     * which is the only name `blastRadiusAnalyzer` can look up. A class member is
+     * always `false`.
+     */
+    exported: boolean;
+    /** 1-based, inclusive, in the "after" file. Zero for removed symbols. */
+    range: {
+        startLine: number;
+        endLine: number;
+    };
+    change: "added" | "modified" | "removed";
+}
+export type FileStatus = "added" | "modified" | "deleted" | "renamed";
+export interface ChangedFile {
+    path: string;
+    status: FileStatus;
+    previousPath?: string;
+    hunks: Hunk[];
+    /** Empty for files that are not TypeScript. */
+    symbols: ChangedSymbol[];
+}
+export interface Changeset {
+    range: RevRange;
+    files: ChangedFile[];
+    /**
+     * Untracked files present in the working tree, which `git diff` omits and
+     * this changeset therefore does not describe. Reported so their absence is
+     * visible; zero when the range ends at a commit.
+     */
+    untrackedCount?: number;
+}
+export type EffectKind = "network" | "filesystem" | "process" | "env" | "database" | "timing";
+export type FactKind = "effect_added" | "effect_removed" | "guard_removed" | "export_added" | "export_removed" | "signature_changed" | "blast_radius" | "citation_rot";
+export interface EvidenceRef {
+    file: string;
+    line: number;
+    excerpt: string;
+    /**
+     * Which revision `line` counts in. A removal — a guard, an effect, or an
+     * export that exists only on the before side — can only be evidenced by
+     * before-side text, whose line numbers need not exist in the working tree
+     * at all. Rendering that as a bare `path:line` sends anyone clicking
+     * through to an unrelated line. Omitted means the after side, which is
+     * the common case and needs no annotation.
+     */
+    side?: "before" | "after";
+}
+export interface Fact {
+    /**
+     * Stable within a single run; referenced by a model claim's
+     * `correspondsTo` in Plan 3, which is what introduces model claims.
+     */
+    id: string;
+    kind: FactKind;
+    /** Always equal to `evidence[0].file` — see `makeFact`, which derives it. */
+    file: string;
+    /** Always equal to `evidence[0].line` — see `makeFact`, which derives it. */
+    line: number;
+    /**
+     * The dotted path to the symbol this fact is about — `Worker.run`, not
+     * `run` — for the same reason `ChangedSymbol.qualifiedName` is: two classes
+     * in one file may each declare `render`, and a method may share a name with
+     * a top-level export. Named for the qualification rather than called
+     * `symbol` because `foldReach` matches facts across analyzers on
+     * (`file`, this): an analyzer that filled it with a bare name handed one
+     * symbol's reference count to another symbol's finding, and the field's
+     * old name made that look correct at every call site. Omitted by
+     * file-scoped facts, which are about no symbol at all.
+     */
+    qualifiedSymbol?: string;
+    detail: Record<string, unknown>;
+    /** At least one. A fact that cannot show its evidence is not emitted. */
+    evidence: EvidenceRef[];
+}
+export type Tier = "verified" | "inferred" | "model";
+export interface Finding {
+    id: string;
+    tier: Tier;
+    file: string;
+    line: number;
+    /** One line, shown as the finding headline. */
+    title: string;
+    /** One or two sentences of supporting explanation. */
+    body: string;
+    score: number;
+    evidence: EvidenceRef[];
+    /**
+     * How widely the changed symbol is used, when known. Not a finding of its
+     * own — an amplifier on this one. See `foldReach`.
+     */
+    reach?: {
+        references: number;
+        sites: EvidenceRef[];
+    };
+    /** The model's reasoning, when a claim contributed to this finding. */
+    claim?: {
+        summary: string;
+        reasoning: string;
+    };
+    /**
+     * Carried over from the claim behind this finding; see `Claim.beyondIntent`.
+     * Lives here rather than inside `claim` so both reconcile paths set one
+     * field and `toFindingView` reads one field — a standalone finding has no
+     * `claim` object to hang it on. Never present on a `verified` finding: see
+     * `test/score/reconcile.test.ts`, "never renders a marker on a verified
+     * finding".
+     */
+    beyondIntent?: true;
+}
+/**
+ * A model's interpretation of a change. A claim is not evidence: it carries
+ * no `EvidenceRef` of its own, and it can never overwrite a fact. It either
+ * annotates a fact — earning that fact's finding a richer explanation — or
+ * stands alone as something the analyzers did not see, labelled `model` so a
+ * reader knows to check it.
+ */
+export interface Claim {
+    id: string;
+    file: string;
+    line: number;
+    /** One sentence, shown as the finding headline when the claim stands alone. */
+    summary: string;
+    /** Why this matters. Shown as the body. */
+    reasoning: string;
+    /**
+     * The model's own 0..1 severity, advisory only. `reconcile` clamps it
+     * defensively (non-finite or out-of-range input becomes 0..1) before
+     * scaling a standalone finding's score, and that scale's ceiling sits
+     * strictly below the weakest score any analyzer fact can produce — so
+     * severity can move a claim within the model tier but never lift it past
+     * a fact.
+     */
+    severity: number;
+    /** `Fact.id` this claim restates or explains, when it corresponds to one. */
+    correspondsTo?: string;
+    /**
+     * Set when the model says the change does something its stated intent does
+     * not account for. Absent or `true`, never `false`: there is no "covered by
+     * the stated intent" finding, only the absence of a mark.
+     */
+    beyondIntent?: true;
+}
+export interface InterpretResult {
+    claims: Claim[];
+    /**
+     * The model that produced them, for the report's provenance line. Empty
+     * when the stage was skipped: a model that was merely *requested* produced
+     * nothing, and naming it would attribute a stage that never ran.
+     */
+    model: string;
+    /** Set when the stage did not run; the reason is shown to the user. */
+    skipped?: string;
+    /**
+     * What the reader is owed about the stated intent when the stage ran but
+     * could not compare against a complete one. Mutually exclusive with
+     * `skipped`: a stage that did not run has nothing to say about intent. See
+     * `test/interpret/index.test.ts`, "never carries both a skipped reason and
+     * an intent note".
+     */
+    intentNote?: string;
+}
+export interface AnalysisContext {
+    cwd: string;
+    range: RevRange;
+    /** File contents at a revision, or null if absent there. */
+    readAt(rev: string, path: string): Promise<string | null>;
+    /**
+     * A type-checked program at a revision. Built lazily and memoized —
+     * constructing one parses every TypeScript file in the repository, so
+     * analyzers that do not need the checker must not call this.
+     */
+    programAt(rev: string): Promise<ts.Program>;
+}
+export type Analyzer = (changeset: Changeset, ctx: AnalysisContext) => Promise<Fact[]>;

package/dist/types.js

@@ -0,0 +1,10 @@
+/** Sentinel revision: read files from the working tree rather than git. */
+export const WORKTREE = "WORKTREE";
+/**
+ * Directory, relative to the repository root, that urtext writes its own
+ * reports into. Lives here rather than in `report/write.ts` because
+ * `extract/diff.ts` needs it too — the untracked-file count has to leave
+ * urtext's own output out — and neither of those two modules should have to
+ * import the other to agree on the name.
+ */
+export const REPORT_DIR = ".urtext";

package/fonts/LICENSE

@@ -0,0 +1,187 @@
+Fonts are (c) Bitstream (see below). DejaVu changes are in public domain.
+Glyphs imported from Arev fonts are (c) Tavmjong Bah (see below)
+
+
+Bitstream Vera Fonts Copyright
+------------------------------
+
+Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera is
+a trademark of Bitstream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the fonts accompanying this license ("Fonts") and associated
+documentation files (the "Font Software"), to reproduce and distribute the
+Font Software, including without limitation the rights to use, copy, merge,
+publish, distribute, and/or sell copies of the Font Software, and to permit
+persons to whom the Font Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright and trademark notices and this permission notice shall
+be included in all copies of one or more of the Font Software typefaces.
+
+The Font Software may be modified, altered, or added to, and in particular
+the designs of glyphs or characters in the Fonts may be modified and
+additional glyphs or characters may be added to the Fonts, only if the fonts
+are renamed to names not containing either the words "Bitstream" or the word
+"Vera".
+
+This License becomes null and void to the extent applicable to Fonts or Font
+Software that has been modified and is distributed under the "Bitstream
+Vera" names.
+
+The Font Software may be sold as part of a larger software package but no
+copy of one or more of the Font Software typefaces may be sold by itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT,
+TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME
+FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING
+ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE
+FONT SOFTWARE.
+
+Except as contained in this notice, the names of Gnome, the Gnome
+Foundation, and Bitstream Inc., shall not be used in advertising or
+otherwise to promote the sale, use or other dealings in this Font Software
+without prior written authorization from the Gnome Foundation or Bitstream
+Inc., respectively. For further information, contact: fonts at gnome dot
+org.
+
+Arev Fonts Copyright
+------------------------------
+
+Copyright (c) 2006 by Tavmjong Bah. All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the fonts accompanying this license ("Fonts") and
+associated documentation files (the "Font Software"), to reproduce
+and distribute the modifications to the Bitstream Vera Font Software,
+including without limitation the rights to use, copy, merge, publish,
+distribute, and/or sell copies of the Font Software, and to permit
+persons to whom the Font Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright and trademark notices and this permission notice
+shall be included in all copies of one or more of the Font Software
+typefaces.
+
+The Font Software may be modified, altered, or added to, and in
+particular the designs of glyphs or characters in the Fonts may be
+modified and additional glyphs or characters may be added to the
+Fonts, only if the fonts are renamed to names not containing either
+the words "Tavmjong Bah" or the word "Arev".
+
+This License becomes null and void to the extent applicable to Fonts
+or Font Software that has been modified and is distributed under the 
+"Tavmjong Bah Arev" names.
+
+The Font Software may be sold as part of a larger software package but
+no copy of one or more of the Font Software typefaces may be sold by
+itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL
+TAVMJONG BAH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+Except as contained in this notice, the name of Tavmjong Bah shall not
+be used in advertising or otherwise to promote the sale, use or other
+dealings in this Font Software without prior written authorization
+from Tavmjong Bah. For further information, contact: tavmjong @ free
+. fr.
+
+TeX Gyre DJV Math
+-----------------
+Fonts are (c) Bitstream (see below). DejaVu changes are in public domain.
+
+Math extensions done by B. Jackowski, P. Strzelczyk and P. Pianowski
+(on behalf of TeX users groups) are in public domain.
+
+Letters imported from Euler Fraktur from AMSfonts are (c) American
+Mathematical Society (see below).
+Bitstream Vera Fonts Copyright
+Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera
+is a trademark of Bitstream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the fonts accompanying this license (“Fonts”) and associated
+documentation
+files (the “Font Software”), to reproduce and distribute the Font Software,
+including without limitation the rights to use, copy, merge, publish,
+distribute,
+and/or sell copies of the Font Software, and to permit persons  to whom
+the Font Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright and trademark notices and this permission notice
+shall be
+included in all copies of one or more of the Font Software typefaces.
+
+The Font Software may be modified, altered, or added to, and in particular
+the designs of glyphs or characters in the Fonts may be modified and
+additional
+glyphs or characters may be added to the Fonts, only if the fonts are
+renamed
+to names not containing either the words “Bitstream” or the word “Vera”.
+
+This License becomes null and void to the extent applicable to Fonts or
+Font Software
+that has been modified and is distributed under the “Bitstream Vera”
+names.
+
+The Font Software may be sold as part of a larger software package but
+no copy
+of one or more of the Font Software typefaces may be sold by itself.
+
+THE FONT SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT,
+TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME
+FOUNDATION
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL,
+SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN
+ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR
+INABILITY TO USE
+THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
+Except as contained in this notice, the names of GNOME, the GNOME
+Foundation,
+and Bitstream Inc., shall not be used in advertising or otherwise to promote
+the sale, use or other dealings in this Font Software without prior written
+authorization from the GNOME Foundation or Bitstream Inc., respectively.
+For further information, contact: fonts at gnome dot org.
+
+AMSFonts (v. 2.2) copyright
+
+The PostScript Type 1 implementation of the AMSFonts produced by and
+previously distributed by Blue Sky Research and Y&Y, Inc. are now freely
+available for general use. This has been accomplished through the
+cooperation
+of a consortium of scientific publishers with Blue Sky Research and Y&Y.
+Members of this consortium include:
+
+Elsevier Science IBM Corporation Society for Industrial and Applied
+Mathematics (SIAM) Springer-Verlag American Mathematical Society (AMS)
+
+In order to assure the authenticity of these fonts, copyright will be
+held by
+the American Mathematical Society. This is not meant to restrict in any way
+the legitimate use of the fonts, such as (but not limited to) electronic
+distribution of documents containing these fonts, inclusion of these fonts
+into other public domain or commercial font collections or computer
+applications, use of the outline data to create derivative fonts and/or
+faces, etc. However, the AMS does require that the AMS copyright notice be
+removed from any derivative versions of the fonts which have been altered in
+any way. In addition, to ensure the fidelity of TeX documents using Computer
+Modern fonts, Professor Donald Knuth, creator of the Computer Modern faces,
+has requested that any alterations which yield different font metrics be
+given a different name.
+
+$Id$