cragkit 0.0.0-stage → 1.0.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vaibhav Suman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,22 @@
+Cragkit distribution notice
+
+Cragkit's own code is distributed under the MIT License in LICENSE.
+Copyright (c) 2026 Vaibhav Suman.
+
+Dependencies are separate distributions. Their own licenses and notices continue
+to apply; Cragkit's MIT declaration does not relicense them. Exact required and
+optional versions are declared in each package manifest and the repository locks.
+The Python core requires Pydantic; the Node core requires Zod. PostgreSQL clients,
+HTTP clients, tokenizers, LangChain and MCP SDKs are installed only by the selected
+profile or separate adapter package. Consult those installed distributions for
+their license texts and transitive dependencies.
+
+These Cragkit archives do not bundle database servers, model weights, model
+runtimes or tokenizer rank assets. Supported server/profile names identify
+compatibility, not a redistribution of those products. Tokenizer assets and local
+model assets require explicit application setup and their applicable terms.
+
+Hosted embedding and reranker profiles require an application-owned transport,
+credential and disclosure policy. Cragkit supplies no built-in API key. Provider
+service terms and usage charges are separate from the MIT license for this code.
+No provider call or model download occurs merely by importing the core package.

package/dist/assessment.d.ts

@@ -0,0 +1,10 @@
+import { type Facet } from './results.js';
+/** Validate wire consistency and emitted references; this does not judge source truth. */
+export declare function validate_assessment(evidence: unknown, facets: unknown): readonly Facet[];
+export type Assessment = Readonly<{
+    facets: readonly Facet[];
+    status: 'sufficient' | 'partial' | 'insufficient';
+    policy: string;
+}>;
+/** Assess only exact emitted source spans against a trusted, query-bound policy. */
+export declare function assess_evidence(query: unknown, evidence: unknown, policy?: unknown): Assessment;

package/dist/assessment.js

@@ -0,0 +1,96 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { render_context } from './context.js';
+import { InvalidRequest } from './errors.js';
+import { EvidenceSchema, FacetSchema } from './results.js';
+import { deep_freeze, identity, integer, text, valid_native_json } from './shared.js';
+const hash = (value) => createHash('sha256').update(value, 'utf8').digest('hex');
+const digest = z.string().regex(/^[0-9a-f]{64}$/);
+const Anchor = z.strictObject({
+    claim_id: identity, collection: identity, document_id: identity, revision_id: identity,
+    source_sha256: digest, start_byte: integer(0, Number.MAX_SAFE_INTEGER),
+    end_byte: integer(0, Number.MAX_SAFE_INTEGER), text: text(32768, false),
+}).refine(value => value.end_byte > value.start_byte && Buffer.byteLength(value.text) === value.end_byte - value.start_byte);
+const PolicyFacet = z.strictObject({
+    facet_id: identity, question: text(2048), required: z.boolean(), absence: z.enum(['missing', 'unknown']),
+    anchors: z.array(Anchor).max(16).refine(values => new Set(values.map(value => JSON.stringify(value))).size === values.length),
+});
+const Policy = z.strictObject({
+    policy_id: identity, version: identity, query_sha256: digest, facets: z.array(PolicyFacet).min(1).max(32),
+}).refine(value => Buffer.byteLength(`${value.policy_id}:${value.version}`) <= 256
+    && new Set(value.facets.map(facet => facet.facet_id)).size === value.facets.length
+    && value.facets.reduce((sum, facet) => sum + facet.anchors.length, 0) <= 64
+    && value.facets.reduce((sum, facet) => sum + facet.anchors.reduce((bytes, anchor) => bytes + Buffer.byteLength(anchor.text), 0), 0) <= 262144);
+function evidence_snapshot(input) {
+    render_context(input);
+    return input.map(item => EvidenceSchema.parse(item));
+}
+/** Validate wire consistency and emitted references; this does not judge source truth. */
+export function validate_assessment(evidence, facets) {
+    try {
+        const items = evidence_snapshot(evidence);
+        if (!valid_native_json(facets) || !Array.isArray(facets) || facets.length > 32)
+            throw new InvalidRequest();
+        const normalized = facets.map(value => FacetSchema.parse(value));
+        const ids = new Set(items.map(item => item.evidence_id));
+        if (new Set(normalized.map(facet => facet.facet_id)).size !== normalized.length
+            || normalized.some(facet => facet.evidence_ids.some(id => !ids.has(id))))
+            throw new InvalidRequest();
+        return deep_freeze(normalized);
+    }
+    catch {
+        throw new InvalidRequest();
+    }
+}
+/** Assess only exact emitted source spans against a trusted, query-bound policy. */
+export function assess_evidence(query, evidence, policy = null) {
+    try {
+        const original = text(16384).parse(query);
+        const items = evidence_snapshot(evidence);
+        let facets, policyVersion = 'unassessed.v0';
+        if (policy === null) {
+            facets = [FacetSchema.parse({ facet_id: 'query', question: 'Original query', required: true,
+                    state: 'unknown', evidence_ids: [], assessment_method: 'none', assessment_version: '0' })];
+        }
+        else {
+            if (!valid_native_json(policy))
+                throw new InvalidRequest();
+            const configured = Policy.parse(policy);
+            if (configured.query_sha256 !== hash(original))
+                throw new InvalidRequest();
+            policyVersion = `${configured.policy_id}:${configured.version}`;
+            facets = configured.facets.map(facet => {
+                const declared = new Set(facet.anchors.map(anchor => anchor.claim_id));
+                const matched = new Set(), references = [];
+                for (const item of items) {
+                    let found = false;
+                    for (const anchor of facet.anchors) {
+                        if (item.collection !== anchor.collection || item.document_id !== anchor.document_id
+                            || item.revision_id !== anchor.revision_id || item.source_sha256 !== anchor.source_sha256
+                            || item.start_byte > anchor.start_byte || item.end_byte < anchor.end_byte)
+                            continue;
+                        const slice = Buffer.from(item.text).subarray(anchor.start_byte - item.start_byte, anchor.end_byte - item.start_byte);
+                        if (!slice.equals(Buffer.from(anchor.text)))
+                            continue;
+                        matched.add(anchor.claim_id);
+                        found = true;
+                    }
+                    if (found)
+                        references.push(item.evidence_id);
+                }
+                const state = matched.size === 0 ? facet.absence
+                    : matched.size >= 2 && references.length >= 2 ? 'conflicting'
+                        : declared.size > 1 ? 'unknown' : 'supported';
+                return FacetSchema.parse({ facet_id: facet.facet_id, question: facet.question, required: facet.required,
+                    state, evidence_ids: references, assessment_method: 'reviewed-span', assessment_version: configured.version });
+            });
+        }
+        const required = facets.filter(facet => facet.required);
+        const status = items.length === 0 ? 'insufficient'
+            : required.length > 0 && required.every(facet => facet.state === 'supported') ? 'sufficient' : 'partial';
+        return deep_freeze({ facets, status, policy: policyVersion });
+    }
+    catch {
+        throw new InvalidRequest();
+    }
+}

package/dist/canonical.d.ts

@@ -0,0 +1,32 @@
+export type CanonicalOptions = Readonly<{
+    format?: string;
+    max_source_bytes?: number;
+    target_bytes?: number;
+    max_chunk_bytes?: number;
+    token_counter?: ((text: string) => number) | null;
+    tokenizer_id?: string | null;
+    token_target?: number | null;
+    max_tokens?: number | null;
+}>;
+export type CanonicalChunk = Readonly<{
+    chunk_id: string;
+    ordinal: number;
+    start_byte: number;
+    end_byte: number;
+    text: string;
+    text_sha256: string;
+    oversized_split: boolean;
+    token_count: number | null;
+}>;
+export type CanonicalDocument = Readonly<{
+    canonical_text: string;
+    source_sha256: string;
+    canonical_sha256: string;
+    parser_id: string;
+    chunker_profile: string;
+    format: string;
+    tokenizer_id: string | null;
+    token_count: number | null;
+    chunks: readonly CanonicalChunk[];
+}>;
+export declare function canonicalize(input: string | Uint8Array, options?: CanonicalOptions): CanonicalDocument;

package/dist/canonical.js

@@ -0,0 +1,206 @@
+/** Bounded native text normalization and exact canonical UTF-8 chunk spans. */
+import { createHash } from 'node:crypto';
+import { InvalidRequest } from './errors.js';
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+const blank = (value) => !/[^ \t\r\n\f\v]/.test(value);
+const scalar = (value) => !/[\uD800-\uDFFF]/u.test(value);
+const integer = (value, min, max) => typeof value === 'number' && Number.isSafeInteger(value) && value >= min && value <= max;
+const bytes = (value) => Buffer.byteLength(value, 'utf8');
+function structural_blocks(text, markdown) {
+    const lines = text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    const output = [];
+    const blankLine = (line) => /^[ \t]*(?:\n)?$/.test(line);
+    const heading = (line) => /^ {0,3}#{1,6}(?:[ \t]|\n|$)/.test(line);
+    const fence = (line) => /^ {0,3}(`{3,}|~{3,})/.exec(line);
+    let index = 0;
+    while (index < lines.length) {
+        if (blankLine(lines[index])) {
+            const start = index;
+            while (index < lines.length && blankLine(lines[index]))
+                index++;
+            const value = lines.slice(start, index).join('');
+            if (output.length)
+                output[output.length - 1] += value;
+            else
+                output.push(value);
+            continue;
+        }
+        const start = index;
+        const opening = markdown ? fence(lines[index]) : null;
+        if (opening) {
+            index++;
+            const closing = new RegExp('^ {0,3}' + opening[1][0] + '{' + opening[1].length + ',}[ \\t]*(?:\\n|$)');
+            while (index < lines.length) {
+                const closed = closing.test(lines[index]);
+                index++;
+                if (closed)
+                    break;
+            }
+        }
+        else if (markdown && heading(lines[index]))
+            index++;
+        else {
+            index++;
+            while (index < lines.length && !blankLine(lines[index]) && !(markdown && (heading(lines[index]) || fence(lines[index]))))
+                index++;
+        }
+        while (index < lines.length && blankLine(lines[index]))
+            index++;
+        output.push(lines.slice(start, index).join(''));
+    }
+    return output;
+}
+export function canonicalize(input, options = {}) {
+    try {
+        return canonicalize_checked(input, options);
+    }
+    catch {
+        throw new InvalidRequest();
+    }
+}
+function canonicalize_checked(input, options) {
+    if (!options || typeof options !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(options)))
+        throw new InvalidRequest();
+    const allowed = new Set(['format', 'max_source_bytes', 'target_bytes', 'max_chunk_bytes', 'token_counter', 'tokenizer_id', 'token_target', 'max_tokens']);
+    for (const key of Reflect.ownKeys(options)) {
+        const descriptor = Object.getOwnPropertyDescriptor(options, key);
+        if (typeof key !== 'string' || !allowed.has(key) || !('value' in descriptor) || !descriptor.enumerable)
+            throw new InvalidRequest();
+    }
+    const format = options.format === undefined ? 'text/plain' : options.format;
+    if (typeof format !== 'string')
+        throw new InvalidRequest();
+    if (!['text/plain', 'text/markdown'].includes(format))
+        throw new InvalidRequest();
+    const maximum = options.max_source_bytes === undefined ? 1_048_576 : options.max_source_bytes;
+    const target = options.target_bytes === undefined ? 2048 : options.target_bytes;
+    const hard = options.max_chunk_bytes === undefined ? 32768 : options.max_chunk_bytes;
+    if (!integer(maximum, 1, 16_777_216) || !integer(hard, 4, 32768) || !integer(target, 1, hard))
+        throw new InvalidRequest();
+    const tokenValues = [options.token_counter, options.tokenizer_id, options.token_target, options.max_tokens];
+    const tokenMode = tokenValues.some(value => value !== undefined && value !== null);
+    if (tokenMode && (typeof options.token_counter !== 'function' || typeof options.tokenizer_id !== 'string'
+        || !/^[A-Za-z0-9_.:-]{1,64}$/.test(options.tokenizer_id) || !integer(options.token_target, 1, 1_000_000)
+        || !integer(options.max_tokens, 1, 1_000_000) || options.token_target > options.max_tokens))
+        throw new InvalidRequest();
+    let raw;
+    if (typeof input === 'string') {
+        if (input.length > maximum || !scalar(input) || bytes(input) > maximum)
+            throw new InvalidRequest();
+        raw = Buffer.from(input, 'utf8');
+    }
+    else if (input instanceof Uint8Array) {
+        if (input.byteLength > maximum)
+            throw new InvalidRequest();
+        raw = Uint8Array.from(input);
+    }
+    else
+        throw new InvalidRequest();
+    const source_sha256 = hash(raw);
+    let text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(raw);
+    if (text.startsWith('\uFEFF'))
+        text = text.slice(1);
+    text = text.replace(/\r\n?/g, '\n');
+    if (!scalar(text) || text.includes('\0') || blank(text))
+        throw new InvalidRequest();
+    const canonical_sha256 = hash(text);
+    const profile = tokenMode
+        ? `cragkit.structure.tokens.v1:target_bytes=${target}:max_bytes=${hard}:tokenizer=${options.tokenizer_id}:target=${options.token_target}:max=${options.max_tokens}`
+        : `cragkit.structure.bytes.v1:target=${target}:max=${hard}`;
+    let counterCalls = 0;
+    const count = (value) => {
+        if (!tokenMode)
+            return null;
+        if (++counterCalls > 65536)
+            throw new InvalidRequest();
+        let result;
+        try {
+            result = options.token_counter(value);
+        }
+        catch {
+            throw new InvalidRequest();
+        }
+        if (result instanceof Promise) {
+            // Invalid asynchronous counters must not leave an unhandled rejection behind.
+            void result.catch(() => { });
+            throw new InvalidRequest();
+        }
+        if (!integer(result, 0, Number.MAX_SAFE_INTEGER))
+            throw new InvalidRequest();
+        return result;
+    };
+    const chunks = [];
+    let offset = 0;
+    const emit = (value, oversized) => {
+        if (chunks.length >= 1024)
+            throw new InvalidRequest();
+        const end = offset + bytes(value);
+        const token_count = count(value);
+        if (tokenMode && token_count > options.max_tokens)
+            throw new InvalidRequest();
+        chunks.push(Object.freeze({ chunk_id: hash(`${canonical_sha256}:${offset}:${end}:${profile}`), ordinal: chunks.length,
+            start_byte: offset, end_byte: end, text: value, text_sha256: hash(value), oversized_split: oversized, token_count }));
+        offset = end;
+    };
+    let pending = [];
+    let pendingBytes = 0;
+    let pendingSplit = false;
+    const flush = () => {
+        if (pending.length)
+            emit(pending.join(''), pendingSplit);
+        pending = [];
+        pendingBytes = 0;
+        pendingSplit = false;
+    };
+    const pack = (value, split) => {
+        const valueBytes = bytes(value);
+        if (pending.length) {
+            // Match Python's work budget: impossible byte combinations never call a tokenizer.
+            if (pendingBytes + valueBytes <= target
+                && (!tokenMode || count(pending.join('') + value) <= options.token_target)) {
+                pending.push(value);
+                pendingBytes += valueBytes;
+                pendingSplit ||= split;
+                return;
+            }
+            flush();
+        }
+        pending = [value];
+        pendingBytes = valueBytes;
+        pendingSplit = split;
+    };
+    for (const block of structural_blocks(text, format === 'text/markdown')) {
+        const blockCount = count(block);
+        if (bytes(block) > hard || (tokenMode && blockCount > options.max_tokens)) {
+            // Only oversized structures are split; every split ends at a Unicode scalar boundary.
+            let piece = '';
+            let pieceBytes = 0;
+            for (const point of block) {
+                const combined = piece + point;
+                const pointBytes = bytes(point);
+                const combinedBytes = pieceBytes + pointBytes;
+                const candidateCount = count(combined);
+                if (piece && (combinedBytes > target || combinedBytes > hard || (tokenMode && (candidateCount > options.token_target || candidateCount > options.max_tokens)))) {
+                    pack(piece, true);
+                    piece = point;
+                    pieceBytes = pointBytes;
+                    if (pieceBytes > hard || (tokenMode && count(piece) > options.max_tokens))
+                        throw new InvalidRequest();
+                }
+                else {
+                    if (combinedBytes > hard || (tokenMode && candidateCount > options.max_tokens))
+                        throw new InvalidRequest();
+                    piece = combined;
+                    pieceBytes = combinedBytes;
+                }
+            }
+            if (piece)
+                pack(piece, true);
+        }
+        else
+            pack(block, false);
+    }
+    flush();
+    return Object.freeze({ canonical_text: text, source_sha256, canonical_sha256, parser_id: format === 'text/markdown' ? 'cragkit.markdown.v1' : 'cragkit.text.v1',
+        chunker_profile: profile, format, tokenizer_id: tokenMode ? options.tokenizer_id : null, token_count: count(text), chunks: Object.freeze(chunks) });
+}

package/dist/context.d.ts

@@ -0,0 +1,25 @@
+export declare const CONTEXT_RENDERER = "cragkit.context.v2";
+export declare class Cl100kCounter {
+    #private;
+    readonly tokenizer = "cl100k_base";
+    private constructor();
+    static create(path: string | URL): Promise<Cl100kCounter>;
+    close(): void;
+    count(value: unknown): number;
+}
+export declare function render_context(input: unknown): string;
+export type ContextOptions = {
+    max_tokens: number;
+    reserve?: number;
+    counter?: Cl100kCounter | null;
+    counting_mode?: 'strict' | 'estimated';
+};
+export type CountedContext = Readonly<{
+    context: string;
+    context_tokens: number;
+    total_tokens: number;
+    renderer: typeof CONTEXT_RENDERER;
+    tokenizer: 'cl100k_base' | null;
+    counting_mode: 'strict' | 'estimated';
+}>;
+export declare function count_context(input: unknown, options: ContextOptions): CountedContext;

package/dist/context.js

@@ -0,0 +1,144 @@
+import { createHash } from 'node:crypto';
+import { open } from 'node:fs/promises';
+import { ContextBudgetTooSmall, InvalidRequest, UnsupportedCapability } from './errors.js';
+import { EvidenceSchema } from './results.js';
+import { valid_native_json } from './shared.js';
+export const CONTEXT_RENDERER = 'cragkit.context.v2';
+const issued = new WeakSet();
+const construction = Symbol();
+const SHA256 = '223921b76ee99bde995b7ff738513eef100fb51d18c93597a113bcffe865b2a7';
+const PATTERN = String.raw `'(?i:[sdmt]|ll|ve|re)|[^\r\n\p{L}\p{N}]?+\p{L}++|\p{N}{1,3}+| ?[^\s\p{L}\p{N}]++[\r\n]*+|\s++$|\s*[\r\n]|\s+(?!\S)|\s`;
+export class Cl100kCounter {
+    tokenizer = 'cl100k_base';
+    #encoder;
+    #closed = false;
+    constructor(encoder, token) { if (token !== construction)
+        throw new UnsupportedCapability(); this.#encoder = encoder; issued.add(this); Object.freeze(this); }
+    static async create(path) {
+        let ranks;
+        try {
+            if (typeof path !== 'string' && !(path instanceof URL))
+                throw new InvalidRequest();
+            const stream = await open(path, 'r');
+            try {
+                if (!(await stream.stat()).isFile())
+                    throw new InvalidRequest();
+                const buffer = Buffer.alloc(2_000_001);
+                let size = 0;
+                while (size < buffer.length) {
+                    const { bytesRead } = await stream.read(buffer, size, buffer.length - size, size);
+                    if (bytesRead === 0)
+                        break;
+                    size += bytesRead;
+                }
+                const data = buffer.subarray(0, size);
+                if (size > 2_000_000 || createHash('sha256').update(data).digest('hex') !== SHA256)
+                    throw new InvalidRequest();
+                ranks = data.toString('ascii');
+            }
+            finally {
+                await stream.close();
+            }
+        }
+        catch {
+            throw new InvalidRequest();
+        }
+        try {
+            const name = 'tiktoken/lite';
+            const module = await import(name);
+            return new Cl100kCounter(new module.Tiktoken(ranks, {}, PATTERN), construction);
+        }
+        catch {
+            throw new UnsupportedCapability();
+        }
+    }
+    close() { if (!this.#closed) {
+        this.#encoder.free();
+        this.#closed = true;
+        issued.delete(this);
+    } }
+    count(value) {
+        if (this.#closed)
+            throw new UnsupportedCapability();
+        if (typeof value !== 'string' || value.length > 262144 || !valid_native_json(value) || Buffer.byteLength(value, 'utf8') > 262144)
+            throw new InvalidRequest();
+        try {
+            return this.#encoder.encode(value, [], []).length;
+        }
+        catch {
+            throw new UnsupportedCapability();
+        }
+    }
+}
+export function render_context(input) {
+    if (!Array.isArray(input) || input.length > 64 || !valid_native_json(input))
+        throw new InvalidRequest();
+    try {
+        const items = input.map(value => EvidenceSchema.parse(value));
+        const ids = new Set(), digests = new Map();
+        const ordered = items.map(item => {
+            if (ids.has(item.evidence_id))
+                throw new InvalidRequest();
+            ids.add(item.evidence_id);
+            const key = JSON.stringify([item.collection, item.document_id, item.revision_id]);
+            if (digests.has(key) && digests.get(key) !== item.source_sha256)
+                throw new InvalidRequest();
+            digests.set(key, item.source_sha256);
+            return {
+                evidence_id: item.evidence_id, collection: item.collection, document_id: item.document_id,
+                revision_id: item.revision_id, chunk_id: item.chunk_id, source_locator: item.source_locator,
+                start_byte: item.start_byte, end_byte: item.end_byte, text: item.text,
+                source_sha256: item.source_sha256, text_sha256: item.text_sha256,
+            };
+        });
+        const rendered = JSON.stringify(ordered);
+        if (Buffer.byteLength(rendered, 'utf8') > 262144)
+            throw new InvalidRequest();
+        return rendered;
+    }
+    catch {
+        throw new InvalidRequest();
+    }
+}
+export function count_context(input, options) {
+    if (!options || typeof options !== 'object' || Object.getPrototypeOf(options) !== Object.prototype
+        || Object.getOwnPropertySymbols(options).length)
+        throw new InvalidRequest();
+    const fields = Object.getOwnPropertyDescriptors(options);
+    if (Object.entries(fields).some(([key, value]) => !['max_tokens', 'reserve', 'counter', 'counting_mode'].includes(key)
+        || !('value' in value) || !value.enumerable))
+        throw new InvalidRequest();
+    const maximum = fields.max_tokens?.value;
+    const reserve = fields.reserve ? fields.reserve.value : 256;
+    const mode = fields.counting_mode ? fields.counting_mode.value : 'estimated';
+    if (typeof maximum !== 'number' || !Number.isInteger(maximum) || maximum < 1 || maximum > 1000000
+        || typeof reserve !== 'number' || !Number.isInteger(reserve) || reserve < 0 || reserve > 1000000
+        || (mode !== 'strict' && mode !== 'estimated'))
+        throw new InvalidRequest();
+    const counter = fields.counter?.value;
+    if (mode === 'estimated' && fields.counter && counter !== null)
+        throw new InvalidRequest();
+    if (mode === 'strict' && (!(counter instanceof Cl100kCounter) || !issued.has(counter)))
+        throw new UnsupportedCapability();
+    const count = (value) => {
+        if (mode === 'estimated')
+            return Math.ceil(Buffer.byteLength(value, 'utf8') / 4);
+        try {
+            const result = Cl100kCounter.prototype.count.call(counter, value);
+            if (!Number.isSafeInteger(result) || result < 0)
+                throw new UnsupportedCapability();
+            return result;
+        }
+        catch {
+            throw new UnsupportedCapability();
+        }
+    };
+    const context = render_context(input);
+    if (count('[]') + reserve > maximum)
+        throw new ContextBudgetTooSmall();
+    const context_tokens = count(context);
+    if (context_tokens + reserve > maximum)
+        throw new ContextBudgetTooSmall();
+    return Object.freeze({ context, context_tokens, total_tokens: context_tokens + reserve,
+        renderer: CONTEXT_RENDERER, tokenizer: mode === 'strict' ? 'cl100k_base' : null, counting_mode: mode });
+}

package/dist/contracts.d.ts

@@ -0,0 +1,2 @@
+export * from './requests.js';
+export * from './results.js';

package/dist/contracts.js

@@ -0,0 +1,2 @@
+export * from './requests.js';
+export * from './results.js';