textlane 0.0.0 → 0.2.0

package/build/models/vfile.d.ts

@@ -0,0 +1,52 @@
+import type { Message, MessageOptions, Place } from "./file.ts";
+/**
+ * The file a JavaScript plugin gets, as a vfile: the document, its path, data and messages.
+ * Only what plugins report here reaches the result; native stages report there directly.
+ */
+export declare class HostFile {
+    value: string | undefined;
+    data: Record<string, unknown>;
+    messages: HostMessage[];
+    history: string[];
+    cwd: string;
+    constructor(options: {
+        value?: string;
+        path?: string;
+    });
+    /** The current path; setting it adds to `history`. */
+    get path(): string | undefined;
+    set path(path: string | undefined);
+    get dirname(): string | undefined;
+    get basename(): string | undefined;
+    get extname(): string | undefined;
+    get stem(): string | undefined;
+    /** Report a warning against the file, as vfile's `message`; `origin` is `source:ruleId`. */
+    message(reason: string | Error, options?: MessageOptions | Place | null, origin?: string): HostMessage;
+    /** Report a note against the file, neither a warning nor an error. */
+    info(reason: string | Error, options?: MessageOptions | Place | null, origin?: string): HostMessage;
+    /** Report an error against the file and throw it. */
+    fail(reason: string | Error, options?: MessageOptions | Place | null, origin?: string): never;
+    toString(): string;
+}
+/** A diagnostic a JavaScript plugin reported, as vfile-message has it. */
+export declare class HostMessage extends Error {
+    reason: string;
+    ruleId: string | null;
+    source: string | null;
+    place: Message["place"];
+    line: number | undefined;
+    column: number | undefined;
+    fatal: boolean | null | undefined;
+    file: string;
+    ancestors: unknown[] | undefined;
+    cause: unknown;
+    actual: string | undefined;
+    expected: string[] | undefined;
+    url: string | undefined;
+    note: string | undefined;
+    constructor(reason: string | Error, options?: MessageOptions | Place | null, origin?: string);
+    /** A message a native stage reported, as the file's other messages are. */
+    static fromMessage(message: Message, path: string | undefined): HostMessage;
+    /** The message as it crosses into the crate. */
+    toJSON(): Message;
+}

package/build/models/vfile.js

@@ -0,0 +1,164 @@
+import { basename, dirname, extname } from "node:path";
+/**
+ * The file a JavaScript plugin gets, as a vfile: the document, its path, data and messages.
+ * Only what plugins report here reaches the result; native stages report there directly.
+ */
+export class HostFile {
+    value;
+    data = {};
+    messages = [];
+    history = [];
+    cwd = process.cwd();
+    constructor(options) {
+        this.value = options.value;
+        if (options.path !== undefined)
+            this.history.push(options.path);
+    }
+    /** The current path; setting it adds to `history`. */
+    get path() {
+        return this.history.at(-1);
+    }
+    set path(path) {
+        if (path !== undefined && path !== this.path)
+            this.history.push(path);
+    }
+    get dirname() {
+        return this.path === undefined ? undefined : dirname(this.path);
+    }
+    get basename() {
+        return this.path === undefined ? undefined : basename(this.path);
+    }
+    get extname() {
+        return this.path === undefined ? undefined : extname(this.path);
+    }
+    get stem() {
+        return this.path === undefined ? undefined : basename(this.path, extname(this.path));
+    }
+    /** Report a warning against the file, as vfile's `message`; `origin` is `source:ruleId`. */
+    message(reason, options, origin) {
+        const message = new HostMessage(reason, options, origin);
+        message.file = this.path ?? "";
+        message.fatal = false;
+        this.messages.push(message);
+        return message;
+    }
+    /** Report a note against the file, neither a warning nor an error. */
+    info(reason, options, origin) {
+        const message = this.message(reason, options, origin);
+        message.fatal = null;
+        return message;
+    }
+    /** Report an error against the file and throw it. */
+    fail(reason, options, origin) {
+        const message = this.message(reason, options, origin);
+        message.fatal = true;
+        throw message;
+    }
+    toString() {
+        return this.value ?? "";
+    }
+}
+/** A diagnostic a JavaScript plugin reported, as vfile-message has it. */
+export class HostMessage extends Error {
+    reason;
+    ruleId = null;
+    source = null;
+    place;
+    line;
+    column;
+    fatal;
+    file = "";
+    ancestors;
+    cause;
+    actual;
+    expected;
+    url;
+    note;
+    constructor(reason, options, origin) {
+        const text = typeof reason === "string" ? reason : reason.message;
+        super(text);
+        this.reason = text;
+        if (typeof reason !== "string")
+            this.cause = reason;
+        const settings = readSettings(options);
+        if (settings.cause !== undefined)
+            this.cause = settings.cause;
+        this.ancestors = settings.ancestors;
+        this.ruleId = settings.ruleId ?? null;
+        this.source = settings.source ?? null;
+        if (origin !== undefined) {
+            const index = origin.indexOf(":");
+            if (index === -1)
+                this.ruleId = origin;
+            else
+                [this.source, this.ruleId] = [origin.slice(0, index), origin.slice(index + 1)];
+        }
+        this.place = readPlace(settings.place ?? settings.ancestors?.at(-1));
+        this.line = this.place?.start.line;
+        this.column = this.place?.start.column;
+        this.name = writePlace(this.place);
+    }
+    /** A message a native stage reported, as the file's other messages are. */
+    static fromMessage(message, path) {
+        const options = {
+            place: message.place ?? undefined,
+            ruleId: message.ruleId ?? undefined,
+            source: message.source ?? undefined,
+        };
+        const created = new HostMessage(message.reason, options);
+        created.file = path ?? "";
+        created.fatal = false;
+        return created;
+    }
+    /** The message as it crosses into the crate. */
+    toJSON() {
+        return {
+            reason: this.reason,
+            ruleId: this.ruleId,
+            source: this.source,
+            place: this.place,
+        };
+    }
+}
+// vfile tells options from a place by their keys; anything else is the place itself
+function readSettings(options) {
+    if (!options)
+        return {};
+    return isMessageOptions(options) ? options : { place: options };
+}
+function isMessageOptions(options) {
+    return ["ancestors", "cause", "place", "ruleId", "source"].some(key => key in options);
+}
+function readPlace(place) {
+    if (typeof place !== "object" || place === null)
+        return null;
+    if ("position" in place)
+        return readPlace(place.position);
+    if ("start" in place && "end" in place) {
+        const start = readPoint(place.start);
+        const end = readPoint(place.end);
+        return start && end ? { start, end } : null;
+    }
+    const point = readPoint(place);
+    return point ? { start: point, end: point } : null;
+}
+function readPoint(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    if (!("line" in value && "column" in value))
+        return undefined;
+    const { line, column } = value;
+    if (typeof line !== "number" || typeof column !== "number")
+        return undefined;
+    const offset = "offset" in value && typeof value.offset === "number" ? value.offset : null;
+    return { line, column, offset };
+}
+// unist-util-stringify-position: `1:1-1:2`, or `1:1` for an unknown place
+function writePlace(place) {
+    if (!place)
+        return "1:1";
+    const start = `${place.start.line}:${place.start.column}`;
+    const end = `${place.end.line}:${place.end.column}`;
+    return start === end ? start : `${start}-${end}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vfile.js","sourceRoot":"","sources":["../../models/vfile.ts"],"names":[],"mappings":"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","sourcesContent":["import { basename, dirname, extname } from \"node:path\"\nimport type { Message, MessageOptions, Place, Point } from \"./file.ts\"\n\n/**\n * The file a JavaScript plugin gets, as a vfile: the document, its path, data and messages.\n * Only what plugins report here reaches the result; native stages report there directly.\n */\nexport class HostFile {\n  value: string | undefined\n  data: Record<string, unknown> = {}\n  messages: HostMessage[] = []\n  history: string[] = []\n  cwd = process.cwd()\n\n  constructor(options: { value?: string; path?: string }) {\n    this.value = options.value\n    if (options.path !== undefined) this.history.push(options.path)\n  }\n\n  /** The current path; setting it adds to `history`. */\n  get path() {\n    return this.history.at(-1)\n  }\n\n  set path(path: string | undefined) {\n    if (path !== undefined && path !== this.path) this.history.push(path)\n  }\n\n  get dirname() {\n    return this.path === undefined ? undefined : dirname(this.path)\n  }\n\n  get basename() {\n    return this.path === undefined ? undefined : basename(this.path)\n  }\n\n  get extname() {\n    return this.path === undefined ? undefined : extname(this.path)\n  }\n\n  get stem() {\n    return this.path === undefined ? undefined : basename(this.path, extname(this.path))\n  }\n\n  /** Report a warning against the file, as vfile's `message`; `origin` is `source:ruleId`. */\n  message(\n    reason: string | Error,\n    options?: MessageOptions | Place | null,\n    origin?: string,\n  ) {\n    const message = new HostMessage(reason, options, origin)\n    message.file = this.path ?? \"\"\n    message.fatal = false\n    this.messages.push(message)\n    return message\n  }\n\n  /** Report a note against the file, neither a warning nor an error. */\n  info(reason: string | Error, options?: MessageOptions | Place | null, origin?: string) {\n    const message = this.message(reason, options, origin)\n    message.fatal = null\n    return message\n  }\n\n  /** Report an error against the file and throw it. */\n  fail(\n    reason: string | Error,\n    options?: MessageOptions | Place | null,\n    origin?: string,\n  ): never {\n    const message = this.message(reason, options, origin)\n    message.fatal = true\n    throw message\n  }\n\n  toString() {\n    return this.value ?? \"\"\n  }\n}\n\n/** A diagnostic a JavaScript plugin reported, as vfile-message has it. */\nexport class HostMessage extends Error {\n  reason: string\n  ruleId: string | null = null\n  source: string | null = null\n  place: Message[\"place\"]\n  line: number | undefined\n  column: number | undefined\n  fatal: boolean | null | undefined\n  file = \"\"\n  ancestors: unknown[] | undefined\n  cause: unknown\n  actual: string | undefined\n  expected: string[] | undefined\n  url: string | undefined\n  note: string | undefined\n\n  constructor(\n    reason: string | Error,\n    options?: MessageOptions | Place | null,\n    origin?: string,\n  ) {\n    const text = typeof reason === \"string\" ? reason : reason.message\n    super(text)\n    this.reason = text\n    if (typeof reason !== \"string\") this.cause = reason\n    const settings = readSettings(options)\n    if (settings.cause !== undefined) this.cause = settings.cause\n    this.ancestors = settings.ancestors\n    this.ruleId = settings.ruleId ?? null\n    this.source = settings.source ?? null\n    if (origin !== undefined) {\n      const index = origin.indexOf(\":\")\n      if (index === -1) this.ruleId = origin\n      else [this.source, this.ruleId] = [origin.slice(0, index), origin.slice(index + 1)]\n    }\n    this.place = readPlace(settings.place ?? settings.ancestors?.at(-1))\n    this.line = this.place?.start.line\n    this.column = this.place?.start.column\n    this.name = writePlace(this.place)\n  }\n\n  /** A message a native stage reported, as the file's other messages are. */\n  static fromMessage(message: Message, path: string | undefined) {\n    const options = {\n      place: message.place ?? undefined,\n      ruleId: message.ruleId ?? undefined,\n      source: message.source ?? undefined,\n    }\n    const created = new HostMessage(message.reason, options)\n    created.file = path ?? \"\"\n    created.fatal = false\n    return created\n  }\n\n  /** The message as it crosses into the crate. */\n  toJSON(): Message {\n    return {\n      reason: this.reason,\n      ruleId: this.ruleId,\n      source: this.source,\n      place: this.place,\n    }\n  }\n}\n\n// vfile tells options from a place by their keys; anything else is the place itself\nfunction readSettings(\n  options: MessageOptions | Place | null | undefined,\n): MessageOptions {\n  if (!options) return {}\n  return isMessageOptions(options) ? options : { place: options }\n}\n\nfunction isMessageOptions(options: MessageOptions | Place): options is MessageOptions {\n  return [\"ancestors\", \"cause\", \"place\", \"ruleId\", \"source\"].some(key => key in options)\n}\n\nfunction readPlace(place: unknown): Message[\"place\"] {\n  if (typeof place !== \"object\" || place === null) return null\n  if (\"position\" in place) return readPlace(place.position)\n  if (\"start\" in place && \"end\" in place) {\n    const start = readPoint(place.start)\n    const end = readPoint(place.end)\n    return start && end ? { start, end } : null\n  }\n  const point = readPoint(place)\n  return point ? { start: point, end: point } : null\n}\n\nfunction readPoint(value: unknown): Point | undefined {\n  if (typeof value !== \"object\" || value === null) return undefined\n  if (!(\"line\" in value && \"column\" in value)) return undefined\n  const { line, column } = value\n  if (typeof line !== \"number\" || typeof column !== \"number\") return undefined\n  const offset =\n    \"offset\" in value && typeof value.offset === \"number\" ? value.offset : null\n  return { line, column, offset }\n}\n\n// unist-util-stringify-position: `1:1-1:2`, or `1:1` for an unknown place\nfunction writePlace(place: Message[\"place\"]) {\n  if (!place) return \"1:1\"\n  const start = `${place.start.line}:${place.start.column}`\n  const end = `${place.end.line}:${place.end.column}`\n  return start === end ? start : `${start}-${end}`\n}\n"]}

package/build/settings.d.ts

@@ -0,0 +1,14 @@
+export interface Platform {
+    /** The npm package that carries this platform's addon. */
+    packageName: string;
+    /** The Rust target the addon is compiled for. */
+    target: string;
+    /** The addon's file name at the package's root. */
+    addon: string;
+}
+/** The npm package users install; it pulls in the one platform package that matches. */
+export declare const PACKAGE_NAME = "textlane";
+/** An environment variable that points at an addon to load instead of the installed one. */
+export declare const ADDON_ENV = "TEXTLANE_ADDON";
+/** Every published platform, keyed by `${process.platform}-${process.arch}`. */
+export declare const PLATFORMS: Record<string, Platform>;

package/build/settings.js

@@ -0,0 +1,17 @@
+/** The npm package users install; it pulls in the one platform package that matches. */
+export const PACKAGE_NAME = "textlane";
+/** An environment variable that points at an addon to load instead of the installed one. */
+export const ADDON_ENV = "TEXTLANE_ADDON";
+/** Every published platform, keyed by `${process.platform}-${process.arch}`. */
+export const PLATFORMS = {
+    "linux-x64": createPlatform("linux-x64", "x86_64-unknown-linux-gnu"),
+    "linux-arm64": createPlatform("linux-arm64", "aarch64-unknown-linux-gnu"),
+    "darwin-x64": createPlatform("darwin-x64", "x86_64-apple-darwin"),
+    "darwin-arm64": createPlatform("darwin-arm64", "aarch64-apple-darwin"),
+    "win32-x64": createPlatform("win32-x64", "x86_64-pc-windows-msvc"),
+    "win32-arm64": createPlatform("win32-arm64", "aarch64-pc-windows-msvc"),
+};
+function createPlatform(key, target) {
+    return { packageName: `@textlane/${key}`, target, addon: "textlane.node" };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,12 +1,45 @@
 {
   "name": "textlane",
-  "version": "0.0.0",
-  "description": "Placeholder reserving the name; the first real release follows",
+  "version": "0.2.0",
+  "description": "Rust-native text processing pipeline — a unified replacement with native and JavaScript plugins",
+  "keywords": [
+    "ast",
+    "html",
+    "markdown",
+    "mdx",
+    "pipeline",
+    "unified"
+  ],
+  "homepage": "https://textlane.dev",
   "license": "MIT",
+  "author": "Evgeny Karev",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/datisthq/textlane.git",
     "directory": "typescript"
   },
-  "homepage": "https://textlane.dev"
+  "files": [
+    "build",
+    "skills"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./build/index.js",
+    "./md": "./build/generated/md.js",
+    "./html": "./build/generated/html.js",
+    "./mdx": "./build/generated/mdx.js",
+    "./nl": "./build/generated/nl.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "optionalDependencies": {
+    "@textlane/linux-x64": "0.2.0",
+    "@textlane/linux-arm64": "0.2.0",
+    "@textlane/darwin-x64": "0.2.0",
+    "@textlane/darwin-arm64": "0.2.0",
+    "@textlane/win32-x64": "0.2.0",
+    "@textlane/win32-arm64": "0.2.0"
+  }
 }

package/skills/textlane-usage/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: textlane-usage
+description: Use when installing textlane or calling it from Rust, Node.js or Python — which package each language uses, how to build a pipeline of native plugins, the processor API and what it does not offer yet.
+---
+
+# Textlane Usage
+
+Textlane is a Rust-native text processing pipeline: a replacement for unified whose plugins run
+natively, with Node.js and Python bindings over the same crate. It is pre-release.
+
+## When to use this skill
+
+Invoke when the user asks to:
+
+- Install textlane in a Rust, Node.js or Python project.
+- Turn Markdown into HTML (or HTML into Markdown, MDX into JavaScript, natural language into checks) with
+  textlane, or port a unified, remark, rehype or retext pipeline to it.
+- Check which textlane version is installed.
+
+## Install
+
+| Language | Package                | Install                |
+| -------- | ---------------------- | ---------------------- |
+| Rust     | `textlane` (crates.io) | `cargo add textlane`   |
+| Node.js  | `textlane` (npm)       | `npm install textlane` |
+| Python   | `textlane` (PyPI)      | `pip install textlane` |
+
+Every channel ships the same crate at the same version. npm installs one prebuilt addon for the
+current platform as an optional dependency; never install with `--omit=optional`.
+
+## Plugins
+
+Plugins are grouped by domain and named `<domain>.<name>`, the name unified's ecosystem uses
+spelled out: `md.parse`, `md.gfm`, `md.toHtml`, `html.stringify`, `html.toMarkdown`,
+`mdx.compile`, `nl.parse`, `nl.equality`. Options take the upstream plugin's camelCase
+names (`allowDangerousHtml`, as remark-rehype). A pipeline has one parser and one compiler, and
+bridges such as `md.toHtml` (remark-rehype) change the tree between them.
+
+| Domain | Node.js         | Python          | Rust             |
+| ------ | --------------- | --------------- | ---------------- |
+| `md`   | `textlane/md`   | `textlane.md`   | `textlane::md`   |
+| `html` | `textlane/html` | `textlane.html` | `textlane::html` |
+| `mdx`  | `textlane/mdx`  | `textlane.mdx`  | `textlane::mdx`  |
+| `nl`   | `textlane/nl`   | `textlane.nl`   | `textlane::nl`   |
+
+`pluginNames()` (Node.js) and `textlane.plugin_names()` (Python) list every plugin.
+
+## Node.js
+
+```js
+import { textlane } from "textlane"
+import * as html from "textlane/html"
+import * as md from "textlane/md"
+
+const file = await textlane()
+  .use(md.parse())
+  .use(md.gfm())
+  .use(md.toHtml({ allowDangerousHtml: true }))
+  .use(html.stringify({ allowDangerousHtml: true }))
+  .process("# hi")
+file.value // "<h1>hi</h1>"
+file.messages // [{ reason, ruleId, source, place }]
+```
+
+A domain function returns a descriptor, `{ name: "md.toHtml", options }`, typed from the
+crate. The processor follows unified: `use(plugin | [plugin, options] | preset | list)`,
+`data(key?, value?)`, `freeze()`, `parse(text)`, `run(tree, file?)` (Promise),
+`runSync(tree, file?)`, `stringify(tree)`, `process(text)` (Promise) and `processSync(text)`.
+Trees are plain unist JSON objects.
+
+## Python
+
+```python
+from textlane import html, md, textlane
+
+file = (
+    textlane()
+    .use(md.parse())
+    .use(md.gfm())
+    .use(md.to_html({"allowDangerousHtml": True}))
+    .use(html.stringify())
+    .process("# hi")
+)
+file["value"]  # "<h1>hi</h1>"
+```
+
+Functions are snake_case (`md.to_html`, `nl.indefinite_article`); their options stay the
+camelCase keys the plugin takes, typed as `TypedDict`s. `process(text)` and `run(tree)`
+return directly; `await processor.aprocess(text)` and `await processor.arun(tree)` are their
+coroutines. A
+file and a tree are dicts.
+
+## Rust
+
+```rust
+use textlane::{Processor, html, md};
+
+let processor = Processor::new()
+    .with(md::Parse::default())
+    .with(md::ToHtml::default())
+    .with(html::Stringify::default())
+    .freeze()?;
+let output = processor.process("# hi")?; // output.value, output.file.messages
+```
+
+## Memory
+
+A document's trees are built in working memory that each thread keeps afterwards, emptied, so
+the next document reuses it instead of asking the system again. At most 256 MB is kept per
+thread; a larger document's memory is freed once it finishes. Change the cap, in bytes, with
+`setRetainedMemory(bytes)` (Node.js), `textlane.set_retained_memory(bytes)` (Python) or
+`textlane::set_retained_memory(bytes)` (Rust), and read it back with `retainedMemory()`,
+`textlane.retained_memory()` or `textlane::read_retained_memory()`. It applies to every
+processor in the process. Raise it for documents of several megabytes, which need more
+than 256 MB of working memory; lower it, or set `0`, when idle memory matters more than speed.
+
+## Errors
+
+Failures raise an `Error` (Node.js) or `textlane.TextlaneError` (Python) whose `code` names
+the case: `unknown-plugin`, `invalid-options`, `missing-parser`, `missing-compiler`,
+`frozen-processor`, `async-in-sync`, `invalid-message`. Handle by code, not by message.
+
+## Not yet
+
+- A JavaScript or Python plugin joins only as a transformer: `use(fn, options)` calls it at
+  freeze (`this` is the processor in JavaScript, the first argument in Python) and runs what it
+  returns over the JSON tree; its file is vfile-shaped, its path from `process({value, path})`.
+  The tree crosses as JSON, so non-JSON values in nodes or `data` do not survive a native
+  stage. Syntax plugins (remark-gfm, remark-directive, remark-math) need the native ones; do
+  not port a pipeline that needs one textlane lacks, say so. A remark plugin that only turns
+  directives, `> [!NOTE]` alerts, definition lists or fenced code into MDX JSX elements is a
+  rule of `md.component` instead. A file-tree directive (livemark's `:::filetree`) is a rule with `treeAs`. remark-heading-id, strip-markdown, rehype-unwrap-images and
+  @stefanprobst/rehype-extract-toc are `md.headingId`, `md.strip`, `html.unwrapImages` and
+  `html.extractToc`; the table of contents lands in the result's `data.toc`. rehype-external-links is `html.externalLinks` (JSON options, no functions), and
+  `md.headingId({ attributes: true })` reads `{#id .class key=value}`. vfile-matter is
+  `md.frontmatter({ data: true })` (add `strip: true` to drop the node, `matters` for TOML too):
+  the YAML lands in the result's `data.matter`, `{}` without one; bad YAML fails with
+  `invalid-frontmatter`. An npm2yarn-style remark plugin (`@docusaurus/remark-plugin-npm2yarn`,
+  npm-to-yarn tabs) is `md.packageCommand`: a fenced `npm`, `pip` or `cargo` block becomes one
+  `PackageTabs` element with an attribute per manager (pnpm, yarn, bun; uv, poetry, pdm;
+  cargo-binstall). remark-toc is
+  `md.toc`: `heading` and `skip` are regex source strings, `parents` a JSON unist-util-is
+  test, never a function; JavaScript lookaround and back references fail with
+  `invalid-options`.
+- Asset and page URLs relative to a Markdown file are `md.pathRewrite({ root, base, pages,
+markdownLinks })`; pass the document as `{ value, path }` so it knows where the file lives.
+- remark-stringify reads `settings` from processor data; textlane's `md.stringify` takes its
+  options directly.