cloving 1.2.0 → 1.3.0

package/dist/src/chats/analysis-batches.js

@@ -1,97 +0,0 @@
-import { analysisDocumentBytes, analysisEvidence, isAnalysisSnapshot, validAnalysisImportId, } from "./analysis-input.js";
-import { analysisLaunchBytes, analysisPrompt, } from "./analysis-prompt.js";
-export const analysisCaptureBytes = 52_428_800;
-export function analysisBatchData(batch, capture) {
-    if (batch.batchIndex === 0 && batch.nextRecordIndex === batch.totalRecords)
-        return { snapshot: capture.snapshot ?? batch.snapshot };
-    return {
-        snapshot: batch.snapshot,
-        context: batch.context,
-        batch: {
-            batchIndex: batch.batchIndex,
-            nextRecordIndex: batch.nextRecordIndex,
-            capturedDigest: capture.digest,
-        },
-    };
-}
-export function prepareAnalysisBatch(snapshot, position) {
-    if (!isAnalysisSnapshot(snapshot) ||
-        !validAnalysisImportId(snapshot.importId))
-        return { kind: "refused", code: "analysis-input-refused" };
-    if (Buffer.byteLength(snapshot.corpus) > analysisCaptureBytes ||
-        [snapshot.redaction, snapshot.structure].some((text) => Buffer.byteLength(text) > analysisDocumentBytes))
-        return { kind: "refused", code: "analysis-too-large" };
-    try {
-        return preparedBatch(snapshot, position);
-    }
-    catch {
-        return { kind: "refused", code: "analysis-input-refused" };
-    }
-}
-function preparedBatch(snapshot, position) {
-    const lines = snapshot.corpus.match(/[^\n]*\n|[^\n]+$/g) ?? [];
-    if (![position.nextRecordIndex, position.completedBatchCount].every(Number.isSafeInteger) ||
-        position.nextRecordIndex < 0 ||
-        position.nextRecordIndex >= lines.length ||
-        position.completedBatchCount < 0 ||
-        position.completedBatchCount > 4)
-        return { kind: "refused", code: "analysis-input-refused" };
-    if (position.completedBatchCount === 4)
-        return { kind: "refused", code: "analysis-batch-limit" };
-    const structure = analysisEvidence(snapshot).structure;
-    let longest = {
-        kind: "refused",
-        code: "analysis-too-large",
-    };
-    for (let end = position.nextRecordIndex + 1; end <= lines.length; end++) {
-        const batch = batchOf(snapshot, { lines, position, end, structure });
-        if (Math.max(batch.launchBytes, Buffer.byteLength(batch.adapterDocument)) >
-            analysisDocumentBytes)
-            break;
-        longest = batch;
-    }
-    return longest;
-}
-function batchOf(snapshot, input) {
-    const { position, lines, end } = input;
-    const batchSnapshot = {
-        ...snapshot,
-        corpus: lines.slice(position.nextRecordIndex, end).join(""),
-        structure: projectedStructure(snapshot.importId, input),
-    };
-    const context = {
-        batchIndex: position.completedBatchCount,
-        firstRecordIndex: position.nextRecordIndex,
-        previousResult: position.previousResult,
-    };
-    const prompt = analysisPrompt(batchSnapshot, context);
-    return {
-        kind: "batch",
-        batchIndex: context.batchIndex,
-        firstRecordIndex: context.firstRecordIndex,
-        nextRecordIndex: end,
-        totalRecords: lines.length,
-        snapshot: batchSnapshot,
-        prompt,
-        launchBytes: analysisLaunchBytes(prompt),
-        adapterDocument: JSON.stringify({ snapshot: batchSnapshot, context }),
-        context,
-    };
-}
-function projectedStructure(importId, input) {
-    const { structure, position, end } = input;
-    return JSON.stringify({
-        schemaVersion: 1,
-        importId,
-        historyCompleteness: structure.historyCompleteness,
-        occurrences: structure.occurrences.slice(position.nextRecordIndex, end),
-        conflictGroups: structure.conflictGroups
-            .map((group) => ({
-            uuid: group.uuid,
-            variants: group.variants
-                .map((variant) => variant.filter((reference) => reference.recordIndex < end))
-                .filter((variant) => variant.length > 0),
-        }))
-            .filter((group) => group.variants.length > 0),
-    });
-}

package/dist/src/chats/analysis-checkpoint.d.ts

@@ -1,29 +0,0 @@
-import type { AnalysisResult } from "./analysis-contract.ts";
-export interface AnalysisCheckpoint {
-    readonly schemaVersion: 1;
-    readonly runId: string;
-    readonly importId: string;
-    readonly capturedDigest: string;
-    readonly batchIndex: number | null;
-    readonly status: "partial" | "complete";
-    readonly result: AnalysisResult | null;
-    readonly total: number;
-    readonly covered: number;
-    readonly uncovered: number;
-    readonly completedBatchCount: number;
-    readonly nextRecordIndex: number;
-}
-export interface AnalysisCheckpointCapture {
-    readonly runId: string;
-    readonly importId: string;
-    readonly digest: string;
-    readonly totalRecords: number;
-}
-export declare function initialAnalysisCheckpoint(capture: AnalysisCheckpointCapture): AnalysisCheckpoint;
-export declare function batchAnalysisCheckpoint(capture: AnalysisCheckpointCapture, position: {
-    readonly batchIndex: number;
-    readonly nextRecordIndex: number;
-    readonly result: AnalysisResult;
-}): AnalysisCheckpoint & {
-    readonly result: AnalysisResult;
-};

package/dist/src/chats/analysis-checkpoint.js

@@ -1,31 +0,0 @@
-export function initialAnalysisCheckpoint(capture) {
-    return {
-        schemaVersion: 1,
-        runId: capture.runId,
-        importId: capture.importId,
-        capturedDigest: capture.digest,
-        batchIndex: null,
-        status: "partial",
-        result: null,
-        total: capture.totalRecords,
-        covered: 0,
-        uncovered: capture.totalRecords,
-        completedBatchCount: 0,
-        nextRecordIndex: 0,
-    };
-}
-export function batchAnalysisCheckpoint(capture, position) {
-    return {
-        ...initialAnalysisCheckpoint(capture),
-        batchIndex: position.batchIndex,
-        status: position.nextRecordIndex === capture.totalRecords &&
-            position.result.openQuestion === undefined
-            ? "complete"
-            : "partial",
-        result: position.result,
-        covered: position.nextRecordIndex,
-        uncovered: capture.totalRecords - position.nextRecordIndex,
-        completedBatchCount: position.batchIndex + 1,
-        nextRecordIndex: position.nextRecordIndex,
-    };
-}

package/dist/src/chats/analysis-contract.d.ts

@@ -1,80 +0,0 @@
-import type { MessageRecord } from "./normalize.ts";
-import type { ImportStructure, OccurrenceReference } from "./structure.ts";
-export declare const analysisCodes: readonly ["not-plain-data", "unknown-version", "invalid-shape", "unknown-kind", "unknown-decision-type", "invalid-question", "question-without-conflict", "missing-source", "unknown-source", "copy-only", "insufficient-repetition", "invalid-loop-limit", "gate-on-non-gate", "authority-field"];
-export type AnalysisCode = (typeof analysisCodes)[number];
-export type ClaimKind = "explicit-human-instruction" | "observed-repetition" | "assistant-claim" | "exception" | "rejected-approach" | "uncertain-inference";
-export type StageActivity = "work" | "routine-repair" | "accidental-interruption" | "tool-imposed-confirmation";
-export type DecisionType = "design-decision" | "configured-action-approval" | "factual-input";
-export interface AnalysisItem {
-    readonly id: string;
-    readonly description: string;
-}
-export interface AnalysisClaim extends AnalysisItem {
-    readonly kind: ClaimKind;
-    readonly sourceRefs: readonly OccurrenceReference[];
-    readonly counterevidenceRefs: readonly OccurrenceReference[];
-}
-export interface AnalysisStage extends AnalysisClaim {
-    readonly activity: StageActivity;
-}
-export interface AnalysisGate extends AnalysisClaim {
-    readonly stageId: string;
-    readonly type: DecisionType;
-}
-export interface AnalysisLoop extends AnalysisClaim {
-    readonly stageIds: readonly string[];
-    readonly maxIterations: number;
-    readonly exitCondition: string;
-    readonly exhaustedStoppingConditionId: string;
-}
-export interface AnalysisBranch extends AnalysisItem {
-    readonly sourceStageId: string;
-    readonly condition: string;
-    readonly targetStageId: string;
-}
-export interface AnalysisNonGate extends AnalysisItem {
-    readonly stageId: string;
-    readonly reason: Exclude<StageActivity, "work">;
-}
-export interface AnalysisProcess {
-    readonly id: string;
-    readonly name: string;
-    readonly scope: string;
-    readonly inputs: readonly AnalysisItem[];
-    readonly stages: readonly AnalysisStage[];
-    readonly branches: readonly AnalysisBranch[];
-    readonly loops: readonly AnalysisLoop[];
-    readonly artifacts: readonly AnalysisItem[];
-    readonly stoppingConditions: readonly AnalysisItem[];
-    readonly gates: readonly AnalysisGate[];
-    readonly nonGates: readonly AnalysisNonGate[];
-}
-export interface AnalysisCandidate {
-    readonly schemaVersion: 1;
-    readonly process: AnalysisProcess;
-    readonly openQuestion?: AnalysisQuestion;
-}
-export interface AnalysisQuestion {
-    readonly claimId: string;
-    readonly description: string;
-    readonly sourceRefs: readonly OccurrenceReference[];
-    readonly choices: readonly AnalysisItem[];
-}
-export interface AnalysisEvidence {
-    readonly records: readonly MessageRecord[];
-    readonly structure: ImportStructure;
-}
-export interface AnalysisResult extends AnalysisCandidate {
-    readonly limitations: {
-        readonly historyCompleteness: "unknown";
-        readonly independentObservations: "not-established";
-        readonly conflictGroups: ImportStructure["conflictGroups"];
-    };
-}
-export type AnalysisValidation = {
-    readonly accepted: true;
-    readonly result: AnalysisResult;
-} | {
-    readonly accepted: false;
-    readonly codes: readonly AnalysisCode[];
-};

package/dist/src/chats/analysis-contract.js

@@ -1,16 +0,0 @@
-export const analysisCodes = [
-    "not-plain-data",
-    "unknown-version",
-    "invalid-shape",
-    "unknown-kind",
-    "unknown-decision-type",
-    "invalid-question",
-    "question-without-conflict",
-    "missing-source",
-    "unknown-source",
-    "copy-only",
-    "insufficient-repetition",
-    "invalid-loop-limit",
-    "gate-on-non-gate",
-    "authority-field",
-];

package/dist/src/chats/analysis-data.d.ts

@@ -1,3 +0,0 @@
-import type { AnalysisCode } from "./analysis-contract.ts";
-export declare function forbiddenAnalysisField(key: string): boolean;
-export declare function inspectAnalysisData(value: unknown): readonly AnalysisCode[];

package/dist/src/chats/analysis-data.js

@@ -1,85 +0,0 @@
-import { isProxy } from "node:util/types";
-export function forbiddenAnalysisField(key) {
-    const name = key.replaceAll(/[-_]/g, "").toLowerCase();
-    return /authority|permission|credential|publish|spend|tdd|^(?:code|scripts?|prompts?|workflows?|executable(?:workflow)?|commands?)$/.test(name);
-}
-function plainPrototype(value) {
-    const prototype = Object.getPrototypeOf(value);
-    const expected = Object.getPrototypeOf(Array.isArray(value) ? [] : {});
-    return (prototype === expected || (prototype === null && !Array.isArray(value)));
-}
-function arrayKeys(value, keys) {
-    return (keys.length === value.length + 1 &&
-        keys.every((key) => typeof key === "string" &&
-            (key === "length" ||
-                (/^(0|[1-9]\d*)$/.test(key) && Number(key) < value.length))));
-}
-function dataMember(value, key) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (!descriptor?.enumerable || !Object.hasOwn(descriptor, "value"))
-        return;
-    const member = descriptor.value;
-    return { key, value: member };
-}
-function members(value) {
-    if (!plainPrototype(value))
-        return;
-    const keys = Reflect.ownKeys(value);
-    if (Array.isArray(value) && !arrayKeys(value, keys))
-        return;
-    const result = [];
-    for (const key of keys) {
-        if (typeof key !== "string")
-            return;
-        if (Array.isArray(value) && key === "length")
-            continue;
-        const member = dataMember(value, key);
-        if (!member)
-            return;
-        result.push(member);
-    }
-    return result;
-}
-function primitive(value) {
-    return (value === null ||
-        typeof value === "string" ||
-        typeof value === "boolean" ||
-        (typeof value === "number" && Number.isFinite(value)));
-}
-export function inspectAnalysisData(value) {
-    const active = new Set();
-    const stack = [{ value }];
-    const codes = new Set();
-    while (stack.length > 0) {
-        const item = stack.pop();
-        if (!item)
-            break;
-        if (item.leave) {
-            active.delete(item.leave);
-            continue;
-        }
-        if (!enqueueData(item.value, { active, stack, codes }))
-            return ["not-plain-data"];
-    }
-    return [...codes];
-}
-function enqueueData(value, context) {
-    if (primitive(value))
-        return true;
-    if (typeof value !== "object" ||
-        value === null ||
-        isProxy(value) ||
-        context.active.has(value))
-        return false;
-    const entries = members(value);
-    if (!entries)
-        return false;
-    context.active.add(value);
-    context.stack.push({ value: null, leave: value });
-    for (const entry of entries) {
-        if (forbiddenAnalysisField(entry.key))
-            context.codes.add("authority-field");
-        context.stack.push({ value: entry.value });
-    }
-    return true;
-}

package/dist/src/chats/analysis-input.d.ts

@@ -1,18 +0,0 @@
-import { type Fields } from "../protocol.ts";
-import type { AnalysisEvidence } from "./analysis-contract.ts";
-export declare const analysisDocumentBytes = 65536;
-export interface AnalysisSnapshot {
-    readonly importId: string;
-    readonly redaction: string;
-    readonly corpus: string;
-    readonly structure: string;
-}
-export declare function validAnalysisImportId(value: string): boolean;
-export declare function isAnalysisSnapshot(value: unknown): value is AnalysisSnapshot;
-export declare function analysisSaveInput(payload: Fields): {
-    snapshot: AnalysisSnapshot;
-    cycleId: string;
-    candidate: unknown;
-    reply: string;
-};
-export declare function analysisEvidence(snapshot: AnalysisSnapshot): AnalysisEvidence;

package/dist/src/chats/analysis-input.js

@@ -1,97 +0,0 @@
-import { record } from "../protocol.js";
-import { parseCorpus } from "./corpus-input.js";
-import { structureImport } from "./structure.js";
-import { categories } from "./redaction.js";
-export const analysisDocumentBytes = 65_536;
-export function validAnalysisImportId(value) {
-    return /^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(value);
-}
-function natural(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function validCounts(value, total) {
-    const counts = record(value);
-    if (counts === undefined || Object.keys(counts).length !== categories.length)
-        return false;
-    return (categories.every((category) => natural(counts[category])) &&
-        natural(total) &&
-        total ===
-            Object.values(counts).reduce((sum, count) => sum + Number(count), 0));
-}
-function validManifest(snapshot, recordCount) {
-    const fields = record(JSON.parse(snapshot.redaction));
-    if (fields === undefined || Object.keys(fields).length !== 6)
-        return false;
-    return (fields["schemaVersion"] === 1 &&
-        fields["ruleVersion"] === 1 &&
-        fields["importId"] === snapshot.importId &&
-        fields["recordCount"] === recordCount &&
-        validCounts(fields["counts"], fields["totalCount"]));
-}
-export function isAnalysisSnapshot(value) {
-    const fields = record(value);
-    return (fields !== undefined &&
-        Object.keys(fields).length === 4 &&
-        ["importId", "redaction", "corpus", "structure"].every((key) => typeof fields[key] === "string"));
-}
-export function analysisSaveInput(payload) {
-    const snapshot = payload["snapshot"];
-    const cycleId = payload["cycleId"];
-    if (!isAnalysisSnapshot(snapshot) ||
-        snapshot.importId !== payload["importId"] ||
-        typeof cycleId !== "string" ||
-        !/^[A-Za-z0-9_-]{1,128}$/.test(cycleId) ||
-        typeof payload["reply"] !== "string")
-        throw new Error("analysis-input-refused");
-    let candidate;
-    try {
-        candidate = JSON.parse(payload["reply"]);
-    }
-    catch {
-        throw new Error("followUp" in payload
-            ? "analysis-follow-up-refused"
-            : "analysis-invalid-json");
-    }
-    return { snapshot, cycleId, candidate, reply: payload["reply"] };
-}
-function canonical(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonical).join(",")}]`;
-    const fields = record(value);
-    if (fields === undefined)
-        return JSON.stringify(value);
-    return `{${Object.keys(fields)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${canonical(fields[key])}`)
-        .join(",")}}`;
-}
-function matchingStructure(value, records) {
-    const fields = record(value);
-    const occurrences = fields?.["occurrences"];
-    if (!Array.isArray(occurrences) || occurrences.length !== records.length)
-        return false;
-    const classified = records.map((message, index) => {
-        const occurrence = record(occurrences[index]);
-        const copy = record(occurrence?.["copyOf"]);
-        return {
-            ...message,
-            role: "user",
-            text: String(copy === undefined ? index : Number(copy["recordIndex"])),
-            blocks: [],
-        };
-    });
-    return canonical(value) === canonical(structureImport(classified));
-}
-export function analysisEvidence(snapshot) {
-    const records = parseCorpus(snapshot.corpus);
-    if (!validManifest(snapshot, records.length))
-        throw new Error("analysis-input-refused");
-    const envelope = record(JSON.parse(snapshot.structure));
-    if (envelope?.["schemaVersion"] !== 1 ||
-        envelope["importId"] !== snapshot.importId)
-        throw new Error("analysis-input-refused");
-    const structure = Object.fromEntries(Object.entries(envelope).filter(([key]) => !["schemaVersion", "importId"].includes(key)));
-    if (!matchingStructure(structure, records))
-        throw new Error("analysis-input-refused");
-    return { records, structure };
-}

package/dist/src/chats/analysis-links.d.ts

@@ -1,2 +0,0 @@
-import type { AnalysisCode, AnalysisProcess } from "./analysis-contract.ts";
-export declare function inspectAnalysisLinks(process: AnalysisProcess): readonly AnalysisCode[];

package/dist/src/chats/analysis-links.js

@@ -1,25 +0,0 @@
-function validNonGate(stage, process) {
-    const classifications = process.nonGates.filter((item) => item.stageId === stage.id);
-    if (stage.activity === "work")
-        return classifications.length === 0;
-    return (classifications.length === 1 &&
-        classifications[0]?.reason === stage.activity &&
-        !process.gates.some((gate) => gate.stageId === stage.id));
-}
-export function inspectAnalysisLinks(process) {
-    const codes = new Set();
-    const stages = new Set(process.stages.map((stage) => stage.id));
-    const stopping = new Set(process.stoppingConditions.map((item) => item.id));
-    if (process.branches.some((branch) => !stages.has(branch.sourceStageId) || !stages.has(branch.targetStageId)))
-        codes.add("invalid-shape");
-    if (process.loops.some((loop) => loop.stageIds.some((id) => !stages.has(id)) ||
-        !stopping.has(loop.exhaustedStoppingConditionId)))
-        codes.add("invalid-shape");
-    if ([...process.gates, ...process.nonGates].some((item) => !stages.has(item.stageId)))
-        codes.add("invalid-shape");
-    if (codes.has("invalid-shape"))
-        return [...codes];
-    if (process.stages.some((stage) => !validNonGate(stage, process)))
-        codes.add("gate-on-non-gate");
-    return [...codes];
-}

package/dist/src/chats/analysis-merge.d.ts

@@ -1,16 +0,0 @@
-import { type AnalysisCode, type AnalysisEvidence, type AnalysisResult } from "./analysis.ts";
-export interface AnalysisMergeInput {
-    readonly previousResult: AnalysisResult | null;
-    readonly candidate: unknown;
-    readonly evidence: AnalysisEvidence;
-    readonly nextRecordIndex: number;
-}
-export type AnalysisMergeCode = AnalysisCode | "analysis-merge-conflict" | "analysis-input-refused";
-export type AnalysisMergeValidation = {
-    readonly accepted: true;
-    readonly result: AnalysisResult;
-} | {
-    readonly accepted: false;
-    readonly codes: readonly AnalysisMergeCode[];
-};
-export declare function mergeAnalysisBatch(input: AnalysisMergeInput): AnalysisMergeValidation;

package/dist/src/chats/analysis-merge.js

@@ -1,134 +0,0 @@
-import { validateAnalysis, } from "./analysis.js";
-import { inspectAnalysisData } from "./analysis-data.js";
-import { inspectAnalysisBatchShape } from "./analysis-shape.js";
-import { analysisCodes } from "./analysis-contract.js";
-import { matchingAnalysisEvidence } from "./analysis-provenance.js";
-const collections = [
-    "inputs",
-    "stages",
-    "branches",
-    "loops",
-    "artifacts",
-    "stoppingConditions",
-    "gates",
-    "nonGates",
-];
-function referencesInOrder(left, right) {
-    const references = new Map([...left, ...right].map((reference) => [
-        JSON.stringify([reference.recordIndex, reference.sourceId]),
-        reference,
-    ]));
-    return [...references.values()].sort((left, right) => left.recordIndex - right.recordIndex);
-}
-function isClaim(item) {
-    return "sourceRefs" in item && "counterevidenceRefs" in item;
-}
-function mergeCollection(previous, incoming) {
-    const merged = new Map(previous.map((item) => [item.id, item]));
-    for (const item of incoming) {
-        const earlier = merged.get(item.id);
-        if (!isClaim(item)) {
-            merged.set(item.id, item);
-            continue;
-        }
-        const prior = earlier !== undefined && isClaim(earlier) ? earlier : undefined;
-        merged.set(item.id, {
-            ...item,
-            sourceRefs: referencesInOrder(prior?.sourceRefs ?? [], item.sourceRefs),
-            counterevidenceRefs: referencesInOrder(prior?.counterevidenceRefs ?? [], item.counterevidenceRefs),
-        });
-    }
-    return [...merged.values()];
-}
-function mergeProcess(previous, incoming) {
-    const earlier = previous ?? incoming;
-    return {
-        ...incoming,
-        inputs: mergeCollection(earlier.inputs, incoming.inputs),
-        stages: mergeCollection(earlier.stages, incoming.stages),
-        branches: mergeCollection(earlier.branches, incoming.branches),
-        loops: mergeCollection(earlier.loops, incoming.loops),
-        artifacts: mergeCollection(earlier.artifacts, incoming.artifacts),
-        stoppingConditions: mergeCollection(earlier.stoppingConditions, incoming.stoppingConditions),
-        gates: mergeCollection(earlier.gates, incoming.gates),
-        nonGates: mergeCollection(earlier.nonGates, incoming.nonGates),
-    };
-}
-function nonReferences(item) {
-    return JSON.stringify(Object.entries(item)
-        .filter(([key]) => !["sourceRefs", "counterevidenceRefs"].includes(key))
-        .sort(([left], [right]) => (left < right ? -1 : Number(left > right))));
-}
-function mergeConflict(previous, incoming) {
-    if (previous === undefined)
-        return false;
-    if (["id", "name", "scope"].some((key) => Reflect.get(previous, key) !== Reflect.get(incoming, key)))
-        return true;
-    const earlier = new Map(collections.flatMap((collection) => previous[collection].map((item) => [item.id, { collection, item }])));
-    return collections.some((collection) => incoming[collection].some((item) => {
-        const prior = earlier.get(item.id);
-        return (prior !== undefined &&
-            (prior.collection !== collection ||
-                nonReferences(prior.item) !== nonReferences(item)));
-    }));
-}
-function processedEvidence(input) {
-    const { records, structure } = input.evidence;
-    const end = input.nextRecordIndex;
-    return {
-        records: records.slice(0, end),
-        structure: {
-            ...structure,
-            counts: { ...structure.counts, records: end },
-            occurrences: structure.occurrences.slice(0, end),
-            conflictGroups: structure.conflictGroups
-                .map((group) => ({
-                ...group,
-                variants: group.variants
-                    .map((variant) => variant.filter((reference) => reference.recordIndex < end))
-                    .filter((variant) => variant.length > 0),
-            }))
-                .filter((group) => group.variants.length > 0),
-        },
-    };
-}
-function priorCodes(previous, evidence) {
-    if (previous === null)
-        return [];
-    const codes = inspectAnalysisData(previous);
-    if (codes.length > 0)
-        return codes;
-    if (previous.openQuestion !== undefined)
-        return ["analysis-input-refused"];
-    const candidate = Object.fromEntries(Object.entries(previous).filter(([key]) => key !== "limitations"));
-    const validation = validateAnalysis(candidate, evidence);
-    return validation.accepted ? [] : validation.codes;
-}
-function validInput(input) {
-    return (Number.isSafeInteger(input.nextRecordIndex) &&
-        input.nextRecordIndex > 0 &&
-        input.nextRecordIndex <= input.evidence.records.length &&
-        matchingAnalysisEvidence(input.evidence));
-}
-export function mergeAnalysisBatch(input) {
-    if (!validInput(input))
-        return { accepted: false, codes: ["analysis-input-refused"] };
-    const evidence = processedEvidence(input);
-    const previousCodes = priorCodes(input.previousResult, evidence);
-    if (previousCodes.length > 0)
-        return { accepted: false, codes: previousCodes };
-    const codes = new Set(inspectAnalysisData(input.candidate));
-    if (codes.has("not-plain-data"))
-        return { accepted: false, codes: ["not-plain-data"] };
-    if (!inspectAnalysisBatchShape(input.candidate, codes) || codes.size > 0)
-        return {
-            accepted: false,
-            codes: analysisCodes.filter((code) => codes.has(code)),
-        };
-    if (mergeConflict(input.previousResult?.process, input.candidate.process))
-        return { accepted: false, codes: ["analysis-merge-conflict"] };
-    return validateAnalysis({
-        ...input.candidate,
-        process: mergeProcess(input.previousResult?.process, input.candidate.process),
-    }, evidence);
-}

package/dist/src/chats/analysis-prompt.d.ts

@@ -1,18 +0,0 @@
-import type { AnalysisResult } from "./analysis-contract.ts";
-import type { AnalysisSnapshot } from "./analysis-input.ts";
-export declare const analysisInstruction: string;
-export interface AnalysisBatchContext {
-    readonly batchIndex: number;
-    readonly firstRecordIndex: number;
-    readonly previousResult: AnalysisResult | null;
-}
-export declare function analysisPrompt(snapshot: AnalysisSnapshot, context?: AnalysisBatchContext): string;
-export declare function analysisLaunchBytes(prompt: string): number;
-export interface AnalysisFollowUp {
-    readonly draft: Readonly<Record<string, unknown>>;
-    readonly answer: string;
-}
-export declare function analysisFollowUpPrompt(snapshot: AnalysisSnapshot, input: AnalysisFollowUp & {
-    readonly context?: Readonly<Record<string, unknown>>;
-}): string;
-export declare function analysisFollowUp(value: unknown): AnalysisFollowUp;