llms-ink 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lucas Espindola
+
+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/README.md

@@ -1,3 +1,101 @@
-# Temporary Holding Version
+# llms-ink
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Turn any link — site, docs section, page, GitHub repo, PDF or video — into llms.txt and llms-full.txt. A typed
+client for the [llms.ink](https://llms.ink) API with no dependencies. Runs on Node 18+, Bun, Deno, Cloudflare
+Workers and browsers.
+
+```sh
+npm install llms-ink        # or: bun add llms-ink
+deno add jsr:@lukax/llms-ink   # or: npx jsr add @lukax/llms-ink
+```
+
+```ts
+import { LlmsInk } from 'llms-ink'; // Deno/JSR: from 'jsr:@lukax/llms-ink'
+
+const ink = new LlmsInk();
+
+const index = await ink.llms('developers.cloudflare.com/kv/');            // llms.txt: an index of links
+const full = await ink.llms('github.com/honojs/hono', { mode: 'full' });  // llms-full.txt: the content
+console.log(full.title, full.tokens, full.text);
+
+const report = await ink.check('llmstxt.org'); // is a site's own llms.txt valid, do its links answer?
+console.log(report.found, report.summary, report.issues);
+```
+
+## API
+
+### `new LlmsInk({ key?, baseUrl?, fetch? })`
+
+- `key`: an API key (`lk_…`), sent as `Authorization: Bearer`. Defaults to the `LLMS_INK_KEY` environment
+  variable where there is one (Node, Bun, Deno with `--allow-env`). Without a key, requests are anonymous and
+  share the free limits. An invalid or revoked key throws `InvalidKeyError`; it never falls back to anonymous.
+- `baseUrl`: defaults to `LLMS_INK_API`, else `https://llms.ink`.
+- `fetch`: a `fetch` to use instead of the global one.
+
+### `ink.llms(url, { mode?, fresh?, signal? })` → `Promise<Result>`
+
+`mode` is `'llms'` (default) or `'full'` (up to 20 pages inlined). `fresh: true` skips the cache and rebuilds
+(counts against the daily quota). The result:
+
+```ts
+{ url, kind, source, mode, title, text, tokens, pages, model, cached, generatedAt, media? }
+```
+
+`kind` is `site | section | page | repo | document | video`; `source` is `native` (the site publishes it) or
+`generated`. `media` is set for videos (duration, thumbnail, downloads, transcript segments).
+
+Building a big site or a video can take minutes. Bound a call with a signal:
+`ink.llms(url, { signal: AbortSignal.timeout(120_000) })`. Aborts are rethrown as is.
+
+### `ink.check(url, { signal? })` → `Promise<CheckResult>`
+
+Checks the site's (or docs section's) published llms.txt against the llmstxt.org format and fetches its first
+25 links: `{ site, url, found, status, title, tokens, sections, links, llmsFull, issues, summary, checkedAt }`.
+
+### `ink.stream(url, { mode?, fresh?, signal? })` → `AsyncGenerator<StreamEvent>`
+
+The same build as `llms()`, as it happens:
+
+```ts
+for await (const event of ink.stream('docs.astro.build', { mode: 'full' })) {
+  if (event.type === 'progress') console.log(event.stage, event.detail);
+  if (event.type === 'partial') preview(event.text); // incomplete so far
+  if (event.type === 'result') save(event.result);   // always last
+}
+```
+
+Breaking out of the loop cancels the request.
+
+## Errors
+
+Every failure is an `LlmsInkError` with `status`, `code`, `title`, `detail`, `errors` (per-parameter issues of
+`invalid_request`) and `retryAfter` (seconds, from `Retry-After`). When llms.ink can't be reached, `status` and
+`code` are undefined and `cause` holds the network error. Codes are listed at
+[llms.ink/docs](https://llms.ink/docs/#errors).
+
+| Class | Status | Code | When |
+|---|---|---|---|
+| `InvalidKeyError` | 401 | `invalid_key` | The key is malformed, unknown or revoked. |
+| `RateLimitedError` | 429 | `rate_limited` | Too many requests this minute; wait `retryAfter` seconds. |
+| `QuotaExceededError` | 429 | `quota_exceeded` | Daily quota of new links used up; `retryAfter` is the seconds until midnight UTC. Cached links still work. |
+
+```ts
+import { LlmsInk, RateLimitedError } from 'llms-ink';
+
+try {
+  await ink.llms('example.com');
+} catch (err) {
+  if (err instanceof RateLimitedError) await new Promise((r) => setTimeout(r, err.retryAfter! * 1000));
+  else throw err;
+}
+```
+
+## Limits
+
+Anonymous: 10 requests a minute per IP, 60 new (uncached) links a day per IP. Cached results are free. A key
+gets its own daily quota (1000 new links by default) and 60 requests a minute;
+[ask for one](https://lucasespindola.com/message?text=Hi+Lucas%2C+I%E2%80%99d+like+an+llms.ink+API+key+for+...).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,229 @@
+/**
+ * Client for the llms.ink JSON API (https://llms.ink/docs/): any public link — site, docs section, page,
+ * GitHub repo, PDF or video — as llms.txt or llms-full.txt. No dependencies; uses the global `fetch`, so it
+ * runs on Node ≥ 18, Bun, Deno, Cloudflare Workers and browsers.
+ *
+ * @example
+ * ```ts
+ * import { LlmsInk } from "llms-ink";
+ *
+ * const ink = new LlmsInk();
+ * const { title, text } = await ink.llms("developers.cloudflare.com/kv/", { mode: "full" });
+ * ```
+ *
+ * @module
+ */
+export declare const VERSION = "0.1.0";
+export declare const DEFAULT_BASE_URL = "https://llms.ink";
+/** `llms` for the index (llms.txt), `full` for llms-full.txt. */
+export type Mode = 'llms' | 'full';
+/** What the link is. */
+export type Kind = 'site' | 'section' | 'page' | 'repo' | 'document' | 'video';
+/** `native` = published by the site; `generated` = made by llms.ink. */
+export type Source = 'native' | 'generated';
+/** A transcript line; `start` and `end` are seconds into the source video. */
+export interface Segment {
+    start: number;
+    end: number;
+    text: string;
+}
+/** Video results only: what `/api/v0/frame` and `/api/v0/media` can serve. */
+export interface Media {
+    /** Seconds. */
+    duration: number | null;
+    hasVideo: boolean;
+    hasAudio: boolean;
+    thumbnail: string | null;
+    downloads: Array<'mp4' | 'm4a'>;
+    isLive?: boolean;
+    transcript?: {
+        source: string;
+        segments: Segment[];
+    };
+}
+/** `GET /api/v0/llms`: the llms.txt or llms-full.txt of a link and what it was built from. */
+export interface Result {
+    /** The link after normalization. */
+    url: string;
+    kind: Kind;
+    source: Source;
+    mode: Mode;
+    title: string;
+    /** The llms.txt or llms-full.txt content (Markdown). */
+    text: string;
+    /** Approximate token count (characters ÷ 4). */
+    tokens: number;
+    /** Links in llms.txt (mode `llms`) or pages inlined (mode `full`). */
+    pages: number;
+    /** Model that wrote the descriptions; null for native files or path-based grouping. */
+    model: string | null;
+    cached: boolean;
+    /** ISO 8601 date-time. */
+    generatedAt: string;
+    media?: Media;
+}
+/** One finding of the checker. */
+export interface CheckIssue {
+    /** `error` breaks the format or a link; `warning` is worth fixing; `info` is a note. */
+    level: 'error' | 'warning' | 'info';
+    /** Stable name of the check, e.g. `missing_title`, `broken_link`. */
+    code: string;
+    /** Line in the file, when the issue has one. */
+    line: number | null;
+    message: string;
+}
+/** `GET /api/v0/check`: a published llms.txt checked against the format and its links. */
+export interface CheckResult {
+    /** The site's origin. */
+    site: string;
+    /** The llms.txt that was checked (or the last place looked when none was found). */
+    url: string;
+    found: boolean;
+    /** HTTP status of the llms.txt request. */
+    status: number;
+    title: string | null;
+    tokens: number;
+    /** H2 sections. */
+    sections: number;
+    links: {
+        total: number;
+        /** Links fetched this run (the first 25). */
+        checked: number;
+        /** `status` is 0 when the link didn't answer in time. */
+        broken: Array<{
+            url: string;
+            status: number;
+        }>;
+    };
+    /** Whether llms-full.txt is published next to it. */
+    llmsFull: boolean;
+    /** Errors first, then warnings and notes, in line order. */
+    issues: CheckIssue[];
+    summary: {
+        errors: number;
+        warnings: number;
+    };
+    /** ISO 8601 date-time. */
+    checkedAt: string;
+}
+/** Every error code the API answers with (https://llms.ink/docs/#errors). */
+export type ErrorCode = 'invalid_request' | 'invalid_url' | 'invalid_key' | 'not_found' | 'unknown_version' | 'method_not_allowed' | 'payload_too_large' | 'unprocessable' | 'rate_limited' | 'quota_exceeded' | 'internal' | 'upstream_error' | 'unavailable' | 'timeout';
+/** `invalid_request` only: one invalid parameter. */
+export interface Issue {
+    path: string;
+    message: string;
+}
+/** An error body (RFC 9457 problem details), sent as `application/problem+json`. */
+export interface Problem {
+    type: string;
+    title: string;
+    status: number;
+    code: ErrorCode;
+    detail: string;
+    errors?: Issue[];
+}
+/** Build stages reported while streaming. */
+export type Stage = 'cache' | 'index' | 'extract' | 'ready';
+/**
+ * One line of the `application/x-ndjson` stream of `GET /api/v0/llms`. `partial` text is explicitly
+ * incomplete; `result` is the last event. A terminal `error` event is thrown as an {@link LlmsInkError}.
+ */
+export type StreamEvent = {
+    type: 'progress';
+    stage: Stage;
+    detail: string;
+} | {
+    type: 'partial';
+    text: string;
+} | {
+    type: 'result';
+    result: Result;
+};
+/** Fields of an {@link LlmsInkError} besides the message. */
+export interface LlmsInkErrorInit {
+    status?: number;
+    code?: string;
+    title?: string;
+    errors?: Issue[];
+    retryAfter?: number;
+    cause?: unknown;
+}
+/**
+ * An API error, or llms.ink couldn't be reached (then `status` and `code` are undefined).
+ * `code` is the problem's machine-readable code (`invalid_url`, `unprocessable`, `upstream_error`…),
+ * `detail` the human-readable message, `errors` the per-parameter issues of `invalid_request`.
+ * `retryAfter` is the `Retry-After` header in seconds, when the response had one.
+ */
+export declare class LlmsInkError extends Error {
+    readonly detail: string;
+    readonly status: number | undefined;
+    readonly code: string | undefined;
+    readonly title: string | undefined;
+    readonly errors: Issue[];
+    readonly retryAfter: number | undefined;
+    constructor(detail: string, init?: LlmsInkErrorInit);
+}
+/** 401 `invalid_key`: the API key is malformed, unknown or revoked. Requests never fall back to anonymous. */
+export declare class InvalidKeyError extends LlmsInkError {
+}
+/** 429 `rate_limited`: too many requests this minute; wait `retryAfter` seconds. */
+export declare class RateLimitedError extends LlmsInkError {
+}
+/**
+ * 429 `quota_exceeded`: the daily quota of new links is used up; `retryAfter` is the seconds until it resets
+ * (midnight UTC). Cached links still work.
+ */
+export declare class QuotaExceededError extends LlmsInkError {
+}
+/** Options for {@link LlmsInk}. */
+export interface LlmsInkOptions {
+    /**
+     * API key (`lk_…`), sent as `Authorization: Bearer`. Defaults to the `LLMS_INK_KEY` environment variable
+     * where there is one; without a key, requests are anonymous and share the free limits.
+     */
+    key?: string;
+    /** Defaults to the `LLMS_INK_API` environment variable, else https://llms.ink. */
+    baseUrl?: string;
+    /** A `fetch` to use instead of the global one. */
+    fetch?: typeof fetch;
+}
+/** Options for {@link LlmsInk.llms} and {@link LlmsInk.stream}. */
+export interface LlmsOptions {
+    /** `llms` (default) for the index, `full` for llms-full.txt (the content inlined, up to 20 pages). */
+    mode?: Mode;
+    /** Skip the cache and rebuild (counts against the daily quota). */
+    fresh?: boolean;
+    /** Aborts the request; the abort error is rethrown as is. */
+    signal?: AbortSignal;
+}
+/** Options for {@link LlmsInk.check}. */
+export interface CheckOptions {
+    signal?: AbortSignal;
+}
+/**
+ * A client for https://llms.ink.
+ *
+ * Building a big site or a video can take minutes; pass a `signal` (e.g. `AbortSignal.timeout(300_000)`) to
+ * bound a call, or use {@link LlmsInk.stream} to watch progress.
+ */
+export declare class LlmsInk {
+    #private;
+    /** The API key in use, if any. */
+    readonly key: string | undefined;
+    /** Origin of the API, without a trailing slash. */
+    readonly baseUrl: string;
+    constructor(options?: LlmsInkOptions);
+    /**
+     * llms.txt (`mode: 'llms'`, an index of links) or llms-full.txt (`mode: 'full'`, the content inlined) for
+     * any public link.
+     */
+    llms(url: string, options?: LlmsOptions): Promise<Result>;
+    /** Checks a site's published llms.txt against the llmstxt.org format and that its links answer. */
+    check(url: string, options?: CheckOptions): Promise<CheckResult>;
+    /**
+     * Like {@link LlmsInk.llms}, as the build happens: yields `progress` and `partial` events, then one
+     * `result`. Errors — including a terminal `error` event — are thrown as {@link LlmsInkError}s.
+     * Breaking out of the loop cancels the request.
+     */
+    stream(url: string, options?: LlmsOptions): AsyncGenerator<StreamEvent, void, undefined>;
+}

package/dist/index.js

@@ -0,0 +1,240 @@
+/**
+ * Client for the llms.ink JSON API (https://llms.ink/docs/): any public link — site, docs section, page,
+ * GitHub repo, PDF or video — as llms.txt or llms-full.txt. No dependencies; uses the global `fetch`, so it
+ * runs on Node ≥ 18, Bun, Deno, Cloudflare Workers and browsers.
+ *
+ * @example
+ * ```ts
+ * import { LlmsInk } from "llms-ink";
+ *
+ * const ink = new LlmsInk();
+ * const { title, text } = await ink.llms("developers.cloudflare.com/kv/", { mode: "full" });
+ * ```
+ *
+ * @module
+ */
+export const VERSION = '0.1.0';
+export const DEFAULT_BASE_URL = 'https://llms.ink';
+/**
+ * An API error, or llms.ink couldn't be reached (then `status` and `code` are undefined).
+ * `code` is the problem's machine-readable code (`invalid_url`, `unprocessable`, `upstream_error`…),
+ * `detail` the human-readable message, `errors` the per-parameter issues of `invalid_request`.
+ * `retryAfter` is the `Retry-After` header in seconds, when the response had one.
+ */
+export class LlmsInkError extends Error {
+    detail;
+    status;
+    code;
+    title;
+    errors;
+    retryAfter;
+    constructor(detail, init = {}) {
+        super(detail, init.cause === undefined ? undefined : { cause: init.cause });
+        this.name = new.target.name;
+        this.detail = detail;
+        this.status = init.status;
+        this.code = init.code;
+        this.title = init.title;
+        this.errors = init.errors ?? [];
+        this.retryAfter = init.retryAfter;
+    }
+}
+/** 401 `invalid_key`: the API key is malformed, unknown or revoked. Requests never fall back to anonymous. */
+export class InvalidKeyError extends LlmsInkError {
+}
+/** 429 `rate_limited`: too many requests this minute; wait `retryAfter` seconds. */
+export class RateLimitedError extends LlmsInkError {
+}
+/**
+ * 429 `quota_exceeded`: the daily quota of new links is used up; `retryAfter` is the seconds until it resets
+ * (midnight UTC). Cached links still work.
+ */
+export class QuotaExceededError extends LlmsInkError {
+}
+const BY_CODE = {
+    invalid_key: InvalidKeyError,
+    rate_limited: RateLimitedError,
+    quota_exceeded: QuotaExceededError,
+};
+const errorFor = (detail, init) => new (BY_CODE[init.code ?? ''] ?? LlmsInkError)(detail, init);
+/** `process.env[name]` where there is a `process` (Node, Bun, Deno with env access); undefined elsewhere. */
+function env(name) {
+    try {
+        return (typeof process === 'undefined' ? undefined : process.env?.[name]?.trim()) || undefined;
+    }
+    catch {
+        return undefined; // Deno without --allow-env throws
+    }
+}
+/** Browsers refuse or preflight a custom User-Agent, so it's only sent from servers. */
+const IS_BROWSER = 'document' in globalThis || 'WorkerGlobalScope' in globalThis;
+/** `Retry-After` as seconds: delta-seconds, or an HTTP date turned into seconds from now. */
+function retryAfter(value) {
+    if (!value)
+        return undefined;
+    const v = value.trim();
+    if (/^\d+$/.test(v))
+        return Number(v);
+    const when = Date.parse(v);
+    return Number.isNaN(when) ? undefined : Math.max(0, Math.ceil((when - Date.now()) / 1000));
+}
+/** Aborts (`signal`, `AbortSignal.timeout`) are the caller's doing and pass through unwrapped. */
+const isAbort = (err) => err instanceof Error && (err.name === 'AbortError' || err.name === 'TimeoutError');
+/**
+ * A client for https://llms.ink.
+ *
+ * Building a big site or a video can take minutes; pass a `signal` (e.g. `AbortSignal.timeout(300_000)`) to
+ * bound a call, or use {@link LlmsInk.stream} to watch progress.
+ */
+export class LlmsInk {
+    /** The API key in use, if any. */
+    key;
+    /** Origin of the API, without a trailing slash. */
+    baseUrl;
+    #fetch;
+    constructor(options = {}) {
+        const key = (options.key ?? env('LLMS_INK_KEY'))?.trim();
+        this.key = key || undefined;
+        this.baseUrl = (options.baseUrl ?? env('LLMS_INK_API') ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        if (!options.fetch && typeof globalThis.fetch !== 'function') {
+            throw new TypeError('No global fetch: use Node 18+ or pass options.fetch.');
+        }
+        // Wrapped so the global is called unbound-safe (browsers throw "Illegal invocation" otherwise).
+        this.#fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    }
+    /**
+     * llms.txt (`mode: 'llms'`, an index of links) or llms-full.txt (`mode: 'full'`, the content inlined) for
+     * any public link.
+     */
+    async llms(url, options = {}) {
+        const res = await this.#get('/api/v0/llms', llmsParams(url, options), 'application/json', options.signal);
+        return (await this.#json(res));
+    }
+    /** Checks a site's published llms.txt against the llmstxt.org format and that its links answer. */
+    async check(url, options = {}) {
+        const res = await this.#get('/api/v0/check', { url }, 'application/json', options.signal);
+        return (await this.#json(res));
+    }
+    /**
+     * Like {@link LlmsInk.llms}, as the build happens: yields `progress` and `partial` events, then one
+     * `result`. Errors — including a terminal `error` event — are thrown as {@link LlmsInkError}s.
+     * Breaking out of the loop cancels the request.
+     */
+    async *stream(url, options = {}) {
+        const res = await this.#get('/api/v0/llms', llmsParams(url, options), 'application/x-ndjson', options.signal);
+        if (!res.headers.get('content-type')?.includes('ndjson')) {
+            yield { type: 'result', result: (await this.#json(res)) };
+            return;
+        }
+        if (!res.body)
+            throw new LlmsInkError(`${this.baseUrl} sent an empty stream.`, { status: res.status });
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let done = false;
+        try {
+            while (!done) {
+                let chunk;
+                try {
+                    chunk = await reader.read();
+                }
+                catch (err) {
+                    if (isAbort(err))
+                        throw err;
+                    throw new LlmsInkError(`The stream from ${this.baseUrl} broke off: ${err instanceof Error ? err.message : err}`, { cause: err });
+                }
+                done = chunk.done;
+                buffer += done ? decoder.decode() : decoder.decode(chunk.value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = done ? '' : lines.pop();
+                for (const line of lines) {
+                    const event = line.trim() ? this.#event(line) : undefined;
+                    if (!event)
+                        continue;
+                    yield event;
+                    if (event.type === 'result')
+                        return;
+                }
+            }
+        }
+        finally {
+            reader.cancel().catch(() => { });
+        }
+        throw new LlmsInkError(`The stream from ${this.baseUrl} ended without a result.`);
+    }
+    /** A stream line → its event; unknown event types (added later) are skipped, `error` is thrown. */
+    #event(line) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch (err) {
+            throw new LlmsInkError(`${this.baseUrl} sent a stream line that isn't JSON.`, { cause: err });
+        }
+        if (!event || typeof event !== 'object' || !('type' in event))
+            return undefined;
+        if (event.type === 'error') {
+            const { detail, code, status } = event;
+            throw errorFor(detail || 'The build failed.', { status, code });
+        }
+        // The server's own event shapes, by type.
+        const known = event.type === 'progress' || event.type === 'partial' || event.type === 'result';
+        return known ? event : undefined;
+    }
+    async #get(path, params, accept, signal) {
+        const headers = { accept };
+        if (!IS_BROWSER)
+            headers['user-agent'] = `llms-ink-js/${VERSION}`;
+        if (this.key)
+            headers.authorization = `Bearer ${this.key}`;
+        const target = `${this.baseUrl}${path}?${new URLSearchParams(params)}`;
+        let res;
+        try {
+            res = await this.#fetch(target, { headers, signal });
+        }
+        catch (err) {
+            if (isAbort(err))
+                throw err;
+            throw new LlmsInkError(`Couldn't reach ${this.baseUrl}: ${err instanceof Error ? err.message : err}`, { cause: err });
+        }
+        if (!res.ok)
+            throw await problem(res);
+        return res;
+    }
+    async #json(res) {
+        const body = await res.text();
+        try {
+            return JSON.parse(body);
+        }
+        catch (err) {
+            throw new LlmsInkError(`${this.baseUrl} answered with something other than JSON.`, { status: res.status, cause: err });
+        }
+    }
+}
+function llmsParams(url, { mode = 'llms', fresh }) {
+    if (mode !== 'llms' && mode !== 'full') {
+        throw new TypeError(`mode must be 'llms' (the index) or 'full' (llms-full.txt), not ${JSON.stringify(mode)}`);
+    }
+    return fresh ? { url, mode, fresh: '1' } : { url, mode };
+}
+/** An HTTP error response → the typed error for its problem `code`. */
+async function problem(res) {
+    let data = {};
+    try {
+        const parsed = JSON.parse(await res.text());
+        if (parsed && typeof parsed === 'object')
+            data = parsed;
+    }
+    catch {
+        // not problem+json: fall back to the status line
+    }
+    const status = typeof data.status === 'number' ? data.status : res.status;
+    const detail = data.detail || data.title || `HTTP ${res.status} ${res.statusText || 'error'}`.trim();
+    return errorFor(detail, {
+        status,
+        code: data.code,
+        title: data.title,
+        errors: data.errors,
+        retryAfter: retryAfter(res.headers.get('retry-after')),
+    });
+}

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "llms-ink",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Turn any link — site, docs section, page, GitHub repo, PDF or video — into llms.txt and llms-full.txt. Typed client for llms.ink, no dependencies.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "sideEffects": false,
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build && npm test",
+    "test": "npm run build && node --test test/client.test.mjs",
+    "test:live": "npm run build && node --test test/live.test.mjs",
+    "test:bun": "npm run build && bun test ./test/client.test.mjs",
+    "test:bun:live": "npm run build && bun test --timeout 300000 ./test/live.test.mjs"
+  },
+  "keywords": ["llms.txt", "llms-full.txt", "llm", "ai", "markdown", "docs", "context", "rag", "sdk", "llms-ink"],
+  "homepage": "https://llms.ink/docs/",
+  "author": "Lucas Espindola (https://lucasespindola.com)",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}