@buildaharness/aielia 0.3.9 → 0.3.10

package/dist/turn-abort.d.ts

@@ -16,3 +16,8 @@ export interface AbortGate {
 export declare function gateLlmClient(client: ILLMClient, gate: AbortGate): ILLMClient;
 /** Rejects with TurnAbortedError as soon as `signal` aborts, without waiting for `work`; `work`'s own late outcome is swallowed. */
 export declare function raceAbort<T>(work: Promise<T>, signal: AbortSignal): Promise<T>;
+/**
+ * A client for one job that can be stopped: every call carries `signal` (so a backend that honours it cuts the request off), the wait ends the
+ * moment it aborts even on a backend that ignores it, and what such a call returns later is dropped. With no signal the client is returned as is.
+ */
+export declare function stoppableLlmClient(client: ILLMClient, signal?: AbortSignal): ILLMClient;

package/dist/version.d.ts

@@ -3,4 +3,4 @@
  * runtime (a bundled/SEA binary has no package.json beside it). `scripts/check-cli-version-sync.mjs`
  * fails CI if this drifts from `package.json`'s `version` — bump both together.
  */
-export declare const CLI_VERSION = "0.3.9";
+export declare const CLI_VERSION = "0.3.10";

package/dist/web-fetch-core.d.ts

@@ -1,17 +1,3 @@
-/**
- * Runtime-agnostic SSRF guard + safe-fetch core used by web-tools.ts (desktop/CLI path). Split
- * out of web-tools.ts so the guard/redirect/byte-cap logic is one focused module instead of
- * living inline in the tool executor.
- *
- * packages/proxy/src/web-fetch.ts (POST /web/fetch, W2) intentionally carries its own copy of
- * this guard rather than importing this module as a workspace dependency — same call W1's
- * web-search.ts already made for the search parsing code: this package's only `exports` entry is
- * the whole `dist/index.js` bundle (nodemailer, the MCP SDK, the CLI), and this repo's proxy CI
- * job (and this plan's own suggested gate script) typechecks/tests packages/proxy without a
- * `build:personal-assistant` step first, so a real cross-package import isn't actually wired up
- * to build here. Keep the two guards in sync by hand if one changes — same discipline the ported
- * DDG/Brave search code in web-search.ts already requires.
- */
 /**
  * Thrown by assertPublicHttpUrl instead of returning a falsy value, so callers
  * can't accidentally proceed past a rejected URL.

package/dist/writer/article-autosave.d.ts

@@ -0,0 +1,12 @@
+/**
+ * When the page should save a version by itself while the writer types: a sentence has been finished (a full stop, question mark or
+ * exclamation mark ends it), a section has been started (a heading line is complete), or the writer has begun changing a different sentence
+ * from the one they were editing, which means they are done with that one. Pure: it looks at the text before and after one change.
+ */
+export interface AutosaveStep {
+    /** `after`: save the text as it is now. `before`: save the text as it was before this change, which is how the sentence stood when the writer left it. */
+    moment: 'before' | 'after' | null;
+    /** Where the sentence being edited starts, to hand back with the next change. */
+    sentenceStart: number | null;
+}
+export declare function autosaveStep(prev: string, next: string, lastSentenceStart: number | null): AutosaveStep;

package/dist/writer/article-change-summary.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What a change did to an article, read from the text before and after: the outline (sections added, removed, renamed, moved) and the
+ * sections whose wording changed. A comparison of the two texts, so the chat can say exactly what happened without asking a model.
+ */
+export interface SectionChange {
+    outline: {
+        added: string[];
+        removed: string[];
+        renamed: {
+            from: string;
+            to: string;
+        }[];
+        moved: string[];
+    };
+    /** The added sections that came with text of their own. */
+    addedWithText: string[];
+    /** Sections that kept their heading and whose text changed. */
+    reworded: string[];
+    /** What was done to the text of each of those, judged by how much of the old wording is left. */
+    how: Record<string, SectionEdit>;
+}
+export type SectionEdit = 'wrote' | 'cleared' | 'rewrote' | 'added to' | 'shortened' | 'reworded';
+export declare function summarizeSectionChange(before: string, after: string): SectionChange;
+/** Marks a section name inside chat text, so the chat can show names in a colour instead of between quotation marks. Private-use characters: they never occur in real text. */
+export declare const NAME_OPEN = "\uE000";
+export declare const NAME_CLOSE = "\uE001";
+/** The summary as lines for the chat: one for the outline (when it changed) and one for the wording. Empty when nothing changed. */
+export declare function describeSectionChange(c: SectionChange): string;

package/dist/writer/article-claims.d.ts

@@ -0,0 +1,49 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { Claim, Section } from './article-model.js';
+/**
+ * Claim extraction and reconciliation (T2). A model reads the sections and says which statements are claims and which
+ * stored claim each one is (by meaning); this module checks that every quote really occurs in the text, gives the claim
+ * its section from the text's own structure, and applies the match rules from the article-model plan, section 6:
+ *  - a sure match keeps the id; changed wording resets the check (editClaimText);
+ *  - an unsure match keeps the claim and marks it "moved or changed, check": not dropped, not silently re-created;
+ *  - a confirmed claim the model no longer finds is kept and marked for a check, never dropped silently;
+ *  - an unconfirmed claim that is gone is dropped but reported;
+ *  - what the model says about a claim the writer confirmed never changes its kind.
+ * Any failure leaves the claims as they were and says so.
+ */
+export interface ExtractionResult {
+    status: 'extracted' | 'not_extracted';
+    claims: Claim[];
+    added: string[];
+    matched: string[];
+    /** Kept but marked needsRecheck because the match was unsure or a confirmed claim could not be found. */
+    flagged: string[];
+    /** Unconfirmed claims that no longer exist in the text. */
+    removed: Claim[];
+    /** Model claims whose quote does not occur in the text, so they cannot be anchored. Reported, not stored. */
+    unanchored: string[];
+}
+/** Sections grouped so one call stays within a size bound. A section larger than the bound goes alone. */
+export declare function batchSections(sections: readonly Section[], markdown: string, maxChars?: number): Section[][];
+export declare function extractClaims(input: {
+    markdown: string;
+    sections: readonly Section[];
+    claims: readonly Claim[];
+    now: string;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<ExtractionResult>;
+/** Links that start or end at a claim the article no longer has (an unconfirmed claim whose sentence was reworded is dropped by extraction): left in place they fail the integrity check. */
+export declare function dropLinksToMissingClaims<M extends {
+    claims: readonly {
+        id: string;
+    }[];
+    links: readonly {
+        from: {
+            type: string;
+            id: string;
+        };
+        to: {
+            type: string;
+            id: string;
+        };
+    }[];
+}>(meta: M): M;

package/dist/writer/article-comments.d.ts

@@ -0,0 +1,20 @@
+import { ArticleMeta } from './article-model.js';
+import { WriterComment } from './writer-chat-state.js';
+import { TextRange } from './article-source-links.js';
+/**
+ * Comments the writer makes on text: highlight a phrase, a sentence, a paragraph or a section, and type. The comment keeps the quoted text; when
+ * the article changes it is found again by that quote, and if the text is gone the comment is kept and marked as outdated, never dropped.
+ */
+export type CommentResult = {
+    ok: true;
+    meta: ArticleMeta;
+    comment: WriterComment;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function addCommentOnText(meta: ArticleMeta, markdown: string, range: TextRange, text: string, now: string): CommentResult;
+/** Comments whose text overlaps the range. Comments that arrived from chat have no text of their own and are not here. */
+export declare function commentsInRange(meta: ArticleMeta, range: TextRange): WriterComment[];
+/** Follows each comment's text through an edit; a comment whose text is gone is marked outdated (and keeps its words). */
+export declare function refreshComments(meta: ArticleMeta, markdown: string): ArticleMeta;

package/dist/writer/article-consistency.d.ts

@@ -0,0 +1,27 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta } from './article-model.js';
+/**
+ * The consistency pass (E10, E11): one model call over the whole article and the text of its sources. It looks for what a check of single claims
+ * against their sources cannot see: two statements of the article that cannot both be true (or a conclusion that does not follow from the article's
+ * own figures), and advice or a general statement that goes further than the sources say they cover. Every judgement is the model's. This module
+ * only keeps findings whose quote is really in the text, marks the section they are in as needing review with the reason (the same mark the resolver
+ * uses; only the writer clears it) and reports what it did. A failure, or an article too long to send whole, leaves the article as it was.
+ */
+export interface ConsistencyFinding {
+    sectionId: string;
+    kind: 'conflict' | 'overreach';
+    quote: string;
+    reason: string;
+}
+export interface ConsistencyResult {
+    status: 'checked' | 'not_checked' | 'too_long';
+    meta: ArticleMeta;
+    findings: ConsistencyFinding[];
+}
+/** The longest article sent whole, in characters. */
+export declare const CONSISTENCY_MAX_ARTICLE_CHARS = 24000;
+export declare function checkConsistency(input: {
+    meta: ArticleMeta;
+    markdown: string;
+    now: string;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<ConsistencyResult>;

package/dist/writer/article-decorations.d.ts

@@ -0,0 +1,23 @@
+import { ArticleMeta } from './article-model.js';
+import { MarkTone } from './article-marks.js';
+/**
+ * Everything the page shows inside the text, as pieces of the text with what applies to each: the tint of a claim's sentence (green, orange or
+ * red), a dotted underline where an open comment sits, a dashed underline where a suggested change would go, and a mark on a heading whose section
+ * needs review. Only styling that does not move the text is possible (the marks are drawn on a copy behind the text area), so detail is not shown
+ * here: the box under the text and the line "Here:" say what is at the cursor. Pure; a decoration is drawn only where the stored text still
+ * stands at the stored place, so text typed since the last save never gets a mark in the wrong place.
+ */
+export interface TextPiece {
+    start: number;
+    end: number;
+    /** The worst claim tone over this piece, when it is inside a claim's sentence. */
+    tone?: MarkTone;
+    claimId?: string;
+    claimStatus?: string;
+    commentIds: string[];
+    suggestionIds: string[];
+    reviewSectionId?: string;
+}
+export declare function textPieces(meta: ArticleMeta, markdown: string): TextPiece[];
+/** What applies at one place in the text, in a short line the page shows under it; undefined when nothing does. */
+export declare function describeAt(pieces: readonly TextPiece[], position: number): string | undefined;

package/dist/writer/article-dependencies.d.ts

@@ -0,0 +1,44 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta, Link } from './article-model.js';
+/**
+ * Dependency mapping between sections (T4). A section "rests on" another when it builds on it (a thesis and its arguments), and
+ * "repeats" another when it restates it (an opening or a conclusion repeating a figure). The assistant proposes links, the writer
+ * confirms, removes or draws them by hand; a confirmed or drawn link is never changed by the assistant. When a section changes,
+ * the resolver uses these links to say which other sections need a look.
+ */
+export declare const DEPENDENCY_KINDS: readonly ["rests_on", "repeats"];
+export type DependencyKind = (typeof DEPENDENCY_KINDS)[number];
+export declare const DEPENDENCY_LABEL: Record<DependencyKind, string>;
+export interface SectionDependencies {
+    /** Links where this section is the one that depends. */
+    uses: Link[];
+    /** Links where another section depends on this one. */
+    usedBy: Link[];
+}
+export declare function dependenciesOf(meta: ArticleMeta, sectionId: string): SectionDependencies;
+/** True when adding "from rests on to" would make a circle of "rests on" links (A rests on B rests on A). */
+export declare function wouldCycle(meta: ArticleMeta, from: string, to: string): boolean;
+export type AddLinkResult = {
+    ok: true;
+    meta: ArticleMeta;
+    link: Link;
+} | {
+    ok: false;
+    reason: string;
+};
+/** The writer draws a link by hand. It is origin "drawn", so the assistant can never remove or change it. */
+export declare function addDrawnLink(meta: ArticleMeta, from: string, to: string, kind: DependencyKind, now: string): AddLinkResult;
+export interface DependencyProposal {
+    status: 'proposed' | 'failed';
+    meta: ArticleMeta;
+    added: Link[];
+    /** Proposals dropped: unknown section, a duplicate, a section depending on itself, or a circle. */
+    skipped: string[];
+    /** Why the search failed, when it did: the error the model call raised, or that its answer could not be read. */
+    reason?: string;
+}
+export declare function proposeDependencies(input: {
+    meta: ArticleMeta;
+    markdown: string;
+    now: string;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<DependencyProposal>;

package/dist/writer/article-draft.d.ts

@@ -0,0 +1,23 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta } from './article-model.js';
+import { ChatTurn } from './writer-chat-history.js';
+export type ArticleDraft = {
+    status: 'drafted';
+    markdown: string;
+    name: string;
+} | {
+    status: 'failed';
+    reason: string;
+};
+/**
+ * The text of the string value of `key` in a JSON object that is still being written, as far as it has arrived: escapes are decoded, an escape cut
+ * in half at the end is left out, and the value is `undefined` until its opening quote has been written. Used to show a draft as it is typed.
+ */
+export declare function partialJsonString(json: string, key: string): string | undefined;
+/** `onText` is given the article as it has been written so far, while the model is still writing; with it the model's reply is read as it streams. */
+export declare function draftArticle(input: {
+    meta: ArticleMeta;
+    instruction: string;
+    current?: string;
+    history?: readonly ChatTurn[];
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void, onText?: (markdownSoFar: string) => void): Promise<ArticleDraft>;

package/dist/writer/article-edit-outline.d.ts

@@ -0,0 +1,16 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta } from './article-model.js';
+import { ChatTurn } from './writer-chat-history.js';
+export type OutlineEdit = {
+    status: 'edited';
+    outline: string;
+} | {
+    status: 'failed';
+    reason: string;
+};
+export declare function editOutline(input: {
+    meta: ArticleMeta;
+    outline: string;
+    instruction: string;
+    history?: readonly ChatTurn[];
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<OutlineEdit>;

package/dist/writer/article-edit-suggest.d.ts

@@ -0,0 +1,30 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta } from './article-model.js';
+import { ChatTurn } from './writer-chat-history.js';
+/**
+ * Turns the writer's instruction ("fix the figure as C1 asks", "tighten the intro") into suggested changes: exact quoted
+ * text plus a replacement and a reason (T9). Nothing is applied here; every suggestion waits for the writer. Quotes that
+ * are not in the text are dropped and reported, so a suggestion can always be found again.
+ */
+export interface EditSuggestResult {
+    status: 'suggested' | 'failed';
+    meta: ArticleMeta;
+    added: string[];
+    /** Model proposals that could not be anchored in the text. */
+    dropped: string[];
+}
+export declare function suggestEdits(input: {
+    meta: ArticleMeta;
+    markdown: string;
+    instruction: string;
+    now: string;
+    modelName?: string; /** Revise only the text in this range: the model is shown it, and a change outside it is dropped. */
+    focus?: {
+        start: number;
+        end: number;
+    };
+    ideaIds?: string[];
+    commentIds?: string[];
+    sectionIds?: string[]; /** The talk so far, so the instruction can refer to it. */
+    history?: readonly ChatTurn[];
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<EditSuggestResult>;

package/dist/writer/article-folder.d.ts

@@ -0,0 +1,29 @@
+import { ARTICLE_META_VERSION, ArticleMeta } from './article-model.js';
+import { Snapshot } from './article-rules.js';
+/**
+ * The portable form of one article (article-model plan, section 2): a small folder, represented here as a map from
+ * path to text so the browser database, an exported folder and the terminal runner all use the same layout.
+ *
+ *   article.md              the text, ordinary Markdown
+ *   article.meta.json       everything else, with its own format version
+ *   sources/<id>.txt        stored source passages, kept out of the main metadata file
+ *   versions/<n>.json       published snapshots and checkpoints
+ *
+ * Loading either succeeds completely or refuses with a message naming what could not be read. Nothing is partly loaded.
+ */
+export type ArticleFolder = Record<string, string>;
+export interface ArticleBundle {
+    markdown: string;
+    meta: ArticleMeta;
+    snapshots: Snapshot[];
+}
+export type FolderLoad = {
+    ok: true;
+    bundle: ArticleBundle;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function serializeArticle(bundle: ArticleBundle): ArticleFolder;
+export declare function loadArticleFolder(folder: ArticleFolder): FolderLoad;
+export { ARTICLE_META_VERSION };

package/dist/writer/article-history.d.ts

@@ -0,0 +1,73 @@
+import { ArticleMeta, SourceStatus } from './article-model.js';
+import { Readiness, Snapshot } from './article-rules.js';
+/**
+ * Versions and what changed between them (article-model plan, section 7). Pure functions: a line diff of the text, the claims
+ * whose shown status changed, the sources added, removed or changed, and the readiness counts side by side.
+ */
+export type DiffLine = {
+    type: 'same' | 'add' | 'del';
+    text: string;
+};
+/** Line diff by longest common subsequence. Articles are small, so the quadratic table is fine; very long inputs fall back to "all replaced". */
+export declare function diffLines(before: string, after: string): DiffLine[];
+export interface VersionSide {
+    markdown: string;
+    meta: ArticleMeta;
+}
+export interface VersionComparison {
+    text: DiffLine[];
+    changedLines: number;
+    claims: {
+        quote: string;
+        from: SourceStatus | 'absent';
+        to: SourceStatus | 'absent';
+    }[];
+    sources: {
+        id: string;
+        address?: string;
+        change: 'added' | 'removed' | 'changed';
+    }[];
+    readiness: {
+        from: Readiness;
+        to: Readiness;
+    };
+}
+export declare function compareVersions(from: VersionSide, to: VersionSide): VersionComparison;
+export interface ChangeSummary {
+    /** No earlier version to compare with. */
+    first: boolean;
+    added: number;
+    removed: number;
+    /** Headings of the sections whose text changed, were added or were removed. */
+    sections: string[];
+    /** Claims whose shown status changed, appeared or disappeared. */
+    claims: number;
+    /** Sources added, removed or changed. */
+    sources: number;
+}
+/** What changed from one version to the next, in a form short enough for one line of a list. `from` is undefined for the first version. */
+export declare function summarizeChange(from: VersionSide | undefined, to: VersionSide): ChangeSummary;
+export declare const MAX_CHECKPOINTS = 20;
+/** The label of a version the page saved by itself, and how many of those are kept (the oldest go first). They do not count towards MAX_CHECKPOINTS. */
+export declare const AUTOSAVE_LABEL = "Autosaved";
+export declare const MAX_AUTOSAVES = 30;
+/** Adds a snapshot, keeping every published one, at most MAX_CHECKPOINTS of the newest checkpoints the writer or an action made, and at most MAX_AUTOSAVES of the newest autosaved ones. */
+export declare function addSnapshot(snapshots: readonly Snapshot[], snapshot: Snapshot, maxCheckpoints?: number): Snapshot[];
+/** True when a new text differs enough from the last one that the writer would want to be able to go back: at least 5 changed lines and 40% of the longer text. */
+export declare function isLargeChange(before: string, after: string): boolean;
+export interface InlinePart {
+    type: 'same' | 'del' | 'add';
+    text: string;
+}
+/** One line of a change as shown to the writer: a line only in one version, or a line changed in place with its words marked. */
+export type DisplayLine = {
+    type: 'add' | 'del';
+    text: string;
+} | {
+    type: 'change';
+    parts: InlinePart[];
+};
+/** The words of a line changed into the words of another, as one run of parts; undefined when the two lines have too little in common to read as an edit of each other. */
+export declare function inlineDiff(before: string, after: string): InlinePart[] | undefined;
+/** The changed lines of a comparison, without the unchanged ones; a removed line and an added line that is an edit of it become one line with the changed words marked. */
+export declare function diffForDisplay(lines: readonly DiffLine[]): DisplayLine[];

package/dist/writer/article-ideas.d.ts

@@ -0,0 +1,34 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta, Idea } from './article-model.js';
+export type IdeaResult = {
+    ok: true;
+    meta: ArticleMeta;
+    idea: Idea;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function addIdea(meta: ArticleMeta, input: {
+    text: string;
+    origin: Idea['origin'];
+    model?: string;
+    sectionId?: string;
+}, now: string): IdeaResult;
+export declare function setIdeaState(meta: ArticleMeta, id: string, state: Idea['state']): IdeaResult;
+export declare function editIdea(meta: ArticleMeta, id: string, patch: {
+    text?: string;
+    sectionId?: string | null;
+}): IdeaResult;
+export declare function removeIdea(meta: ArticleMeta, id: string): ArticleMeta;
+export interface IdeaSuggestion {
+    status: 'suggested' | 'failed';
+    meta: ArticleMeta;
+    added: Idea[];
+}
+export declare function suggestIdeas(input: {
+    meta: ArticleMeta;
+    markdown: string;
+    request?: string;
+    now: string;
+    modelName?: string;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<IdeaSuggestion>;

package/dist/writer/article-issues.d.ts

@@ -0,0 +1,47 @@
+import { ArticleMeta, Claim } from './article-model.js';
+/**
+ * Issues in batches. Everything that needs the writer's attention is grouped by what it is, so it can be dealt with one category at a time
+ * or all together. This module only decides which items belong to which category (from the article's own records, no language judgement);
+ * the service runs the batch actions.
+ *
+ *  suggestions   suggested changes waiting for Accept or Reject
+ *  comments      open reviewer comments the writer can act on (comments in conflict are listed apart: they need the writer's choice)
+ *  checkable     factual claims with a stored source passage that have not been checked, or whose check no longer applies
+ *  unsupported   factual claims with no source, or that their source does not support
+ *  sections      sections marked as needing review
+ *  links         links Aielia proposed (between sections, and between claims and sources) that wait for the writer
+ *  stale         suggestions that can no longer be applied because the text under them changed
+ */
+export type IssueCategory = 'suggestions' | 'comments' | 'checkable' | 'unsupported' | 'sections' | 'links' | 'stale';
+export interface IssueItem {
+    id: string;
+    label: string;
+    detail?: string;
+}
+export interface IssueBatch {
+    category: IssueCategory;
+    title: string;
+    items: IssueItem[];
+    /** Open comments that conflict with each other. Not part of any batch action. */
+    needsYourChoice?: IssueItem[];
+}
+export declare const ISSUE_CATEGORIES: IssueCategory[];
+/** The factual claims that can be checked right now: a stored passage is attached and nothing valid has been said about the claim yet. */
+export declare function checkableClaims(meta: ArticleMeta): Claim[];
+/** The factual claims that are not backed and cannot be checked now: no source, a source with no passage to read, or a source that does not support them. */
+export declare function unsupportedClaims(meta: ArticleMeta): Claim[];
+export declare function collectIssues(meta: ArticleMeta): IssueBatch[];
+export declare function issueCount(batches: readonly IssueBatch[]): number;
+/**
+ * What is left before the article is ready, as plain lines for the answering model, so "what is left?" is answered from the article's own
+ * records and not from a guess. At most a few items per group; empty when nothing is open.
+ */
+export declare function renderIssuesForChat(meta: ArticleMeta, perGroup?: number): string;
+/**
+ * The article's records cut down to what bears on one piece of text, so `collectIssues` on the result lists only the issues there: suggestions and
+ * comments on that text, claims in it, and the section it is in (with the links that start from that section or from a claim in the text).
+ */
+export declare function issuesInRange(meta: ArticleMeta, range: {
+    start: number;
+    end: number;
+}): ArticleMeta;

package/dist/writer/article-marks.d.ts

@@ -0,0 +1,25 @@
+import { ArticleMeta } from './article-model.js';
+/**
+ * Where the page tints the text, and in which of three tones. Pure: a claim is marked only where its stored quote still stands at its stored
+ * position in the text on screen, so text typed since the last save never gets a tint in the wrong place. The tint covers the whole sentence that
+ * holds the claim. Two claims in one sentence share one tint, in the worse tone. Marks never overlap.
+ *
+ * ok (green): the claim is backed by its source. look (orange): it still needs a source, a check, or a better source (no source, not checked yet,
+ * out of date, partly or not backed, or searched for and not found). bad (red): a source says the opposite.
+ */
+export type MarkTone = 'ok' | 'tried' | 'look' | 'bad';
+export interface ClaimMark {
+    /** The sentence the tint covers. */
+    start: number;
+    end: number;
+    claimId: string;
+    tone: MarkTone;
+    /** The status shown to the writer, after the rules for stale and unchecked results. */
+    status: string;
+}
+/** The sentence around a quote: back to the end of the previous sentence or the start of the line, forward to the end punctuation or the end of the line. */
+export declare function sentenceAround(text: string, start: number, end: number): {
+    start: number;
+    end: number;
+};
+export declare function claimMarks(meta: ArticleMeta, markdown: string): ClaimMark[];

package/dist/writer/article-memory-store.d.ts

@@ -0,0 +1,3 @@
+import { MemoryAdapter } from '@buildaharness/runtime';
+import { ArticleStore } from './article-service.js';
+export declare function createMemoryAdapterArticleStore(memory: MemoryAdapter): ArticleStore;