@traq-markdown-engine/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2020 traP
+Copyright (c) 2026 東京工業大学デジタル創作同好会traP
+
+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

@@ -0,0 +1,193 @@
+# sdk: traQ Markdown
+
+traQ 向けの Markdown 文法・通知処理の構成と、Rust・WebAssembly・Go・TypeScript 向けの配布を所有します。文法・AST の契約・検証は Rust が所有します。
+
+- npm: **`@traq-markdown-engine/sdk`**
+- Go module: **`github.com/uni-kakurenbo/traq-markdown-engine/packages/sdk/go`**
+
+文法の実装は [core](../core/README.md)、[commonmark-plugin](../plugins/commonmark/README.md)、[traq-plugin](../plugins/traq/README.md) にあります。このリポジトリで配布するプリセットを選び、Wasm と対応する型を生成します。
+
+## 構成と責任
+
+| 場所                          | 責任                                                                         |
+| ----------------------------- | ---------------------------------------------------------------------------- |
+| `crates/grammar`              | CommonMark・汎用拡張・traP 拡張を選択し、文法プリセットを構成                |
+| `crates/processing`           | AST を受け取る PlainText renderer と extractor、および traQ 向けの方針を構成 |
+| `crates/wasm`                 | 配布する文法・ノード型・処理 API を Wasm として公開                          |
+| `go`・`typescript`・`scripts` | この配布物に対応する bindings と型生成                                       |
+
+共通機構は core、CommonMark と汎用拡張は commonmark、traP 固有の拡張部品は
+traq-plugin にあります。このリポジトリがそれらに依存し、traQ 向けに組み合わせます。
+下位の部品はこの配布物に依存しません。bindings はここで選んだ型とプリセットに対応します。
+
+## ビルド
+
+環境準備、ビルド、検証は [ルートの CONTRIBUTING](../../CONTRIBUTING.md) に従います。Wasm・JavaScript・型定義は `packages/sdk/dist/` に出力します。Rust から生成する TypeScript / Go のソースと、対応する Rust ビルド ID はソース管理します。バイナリと SDK は同じソース・固定依存から生成した組を配布してください。
+
+まだレジストリへ公開していません。TypeScript は4パッケージの `bun pm pack` アーカイブを利用できます。
+
+## TypeScript
+
+```ts
+import { createRuntime, presets } from '@traq-markdown-engine/sdk'
+
+const runtime = await createRuntime(wasmBytes)
+try {
+  const parser = runtime.createParser(presets.traq.v1)
+  const document = parser.parse('**hello** :stamp:')
+  const inline = parser.parseInline('**hello**')
+} finally {
+  runtime.dispose()
+}
+```
+
+`wasmBytes` は `Uint8Array` です。Bun では `Bun.file(new URL(import.meta.resolve('@traq-markdown-engine/sdk/parser.wasm'))).bytes()` で読み、ブラウザーでは `new Uint8Array(await response.arrayBuffer())` を渡します。Runtime と Parser は再利用できます。同じ Runtime から異なるプリセットの Parser も作成できます。
+
+ノード型は判別可能な union です。文法別の payload 型と任意利用の guard は `@traq-markdown-engine/commonmark-plugin/nodes`・`@traq-markdown-engine/commonmark-plugin/generic/nodes`・`@traq-markdown-engine/traq-plugin/nodes`、配布物全体の一覧は `@traq-markdown-engine/sdk/nodes` から利用できます。
+
+## Go
+
+```go
+import markdown "github.com/uni-kakurenbo/traq-markdown-engine/packages/sdk/go"
+
+runtime, err := markdown.NewRuntime(ctx, wasmBytes)
+if err != nil { return err }
+defer runtime.Close(ctx)
+
+parser, err := runtime.NewParser(ctx, markdown.PresetTraQV1)
+if err != nil { return err }
+defer parser.Close(ctx)
+document, err := parser.Parse(ctx, "**hello** :stamp:")
+```
+
+`Parse` / `ParseInline` は `*markdown.Document` を返します。`Node.Data` の具体的な型も Rust から生成します。Runtime は Wasm のコンパイル結果を共有します。一つの Parser の呼び出しは直列化し、並列実行には同じ Runtime から Parser を複数作ります。`Parser.Close` はその Parser だけ、`Runtime.Close` は配下の全 Parser を解放します。
+
+## 文法の変更
+
+文法バージョンは、本文がどの構文規則で書かれたかを示す永続的な識別子です。
+パッケージのバージョンとは独立しており、パッケージを更新しても既存の識別子の意味を変えません。
+processing・renderer には独立した文法バージョンを設けず、選択された文法が生成した AST を処理します。
+
+文法のレジストリは Rust の `bindings::grammars()` にあります。
+`bindings::parser(version)` が名前から Grammar を選び、Parser を生成します。
+Go / TypeScript には文法構成を複製せず、Wasm 境界では文法バージョンの文字列を渡します。
+`presets.traq.v1` / `PresetTraQV1` はその文字列を表す生成済み定数です。
+Rust の配布層がバージョンを解決し、共通のパーサー生成や処理機構は文法バージョンを知りません。
+
+TypeScript の `runtime.createParser(version)`、
+Go の `NewParser(ctx, Preset(version))` に
+DB から読み出したバージョンを指定できます。未知のバージョンはエラーになり、最新文法への暗黙の置き換えはしません。
+同じ Runtime から作成したパーサーを `Map<string, Parser>` に保持して使い分けられます。
+
+```ts
+import type { Parser } from '@traq-markdown-engine/sdk'
+
+const parsers = new Map<string, Parser>()
+for (const message of messages) {
+  let parser = parsers.get(message.grammarVersion)
+  if (!parser) {
+    parser = runtime.createParser(message.grammarVersion)
+    parsers.set(message.grammarVersion, parser)
+  }
+  const document = parser.parse(message.text)
+  const result = view.render(document)
+}
+```
+
+DB に保存するのは永続的な文法バージョンです。SDK と Wasm の対応を確認するビルド ID は
+保存用バージョンではなく、パッケージ更新後も同じ文法バージョンで旧文法を選択できます。
+
+新しい文法は Rust の文法定義と `crates/grammar/src/presets/exports.rs` の公開カタログに追加します。
+選択レジストリと Go / TypeScript の定数はこのカタログを使うため、言語ごとの分岐や processing / renderer のバージョン追加は不要です。
+既存文法の共有ルールを変更するときは、旧文法の解釈を維持してください。解釈を変えるルールだけを分離し、
+旧実装を旧文法に残します。変更のないルールや AST の処理コードを文法ごとに複製する必要はありません。
+既存の v1 AST fixture は互換性検証に使い、文法を更新する目的で期待値を上書きしません。
+
+TypeScript の `presets.commonmark` / `presets.traq.v1`、Go の `PresetCommonMark` / `PresetTraQV1` は Rust が公開するプリセットから生成します。独自の文法は Rust で組み立て、配布層からプリセットとして公開して再ビルドします。ホスト API は文法からのパーサー生成、解析、解放を提供します。
+
+Wasm のホスト実装は TypeScript の `index.ts` と Go の `parser.go` です。共通 AST 型と payload guard の検証部品は core、構文の生成型はそれぞれのパッケージが所有します。文法ビルダー、Plugin / Rule のミラー、文法ハンドル、worker pool は持ちません。
+
+HTML 描画の共通基盤は core、構文別の描画は commonmark-plugin と traq-plugin が担当します。traQ の描画構成・condensed 表示・CSS はこのリポジトリの `typescript/renderer` が所有します。
+
+[API と実装](docs/implementation.md)、[実行例](examples/README.md)、[開発と検証](../../CONTRIBUTING.md) を参照してください。
+
+## AST からの描画と抽出
+
+Parser が返す Document を renderer と extractor に直接渡します。文法を選択するのは Parser だけです。
+TypeScript の HTML renderer はホスト上で AST を描画し、Extractor と Go の PlainTextRenderer は
+渡された AST を Wasm の Rust 実装に渡します。Markdown 原文の再解析は行いません。
+
+```ts
+const parser = runtime.createParser(presets.traq.v1)
+const extractor = runtime.createExtractor({ origin: 'https://q.example.test' })
+const document = parser.parse('**hello** !!secret!!')
+const { references, embedding, messageText } = extractor.extract(document)
+const html = view.render(document)
+```
+
+```go
+parser, err := runtime.NewParser(ctx, markdown.PresetTraQV1)
+if err != nil { return err }
+extractor, err := runtime.NewExtractor(ctx, markdown.ExtractorOptions{Origin: origin})
+if err != nil { return err }
+renderer, err := runtime.NewPlainTextRenderer(ctx, markdown.RendererOptions{Origin: origin})
+if err != nil { return err }
+document, err := parser.Parse(ctx, "**hello** !!secret!!")
+if err != nil { return err }
+metadata, err := extractor.Extract(ctx, document)
+if err != nil { return err }
+notification, err := renderer.Render(ctx, document)
+```
+
+各 instance は同じ Runtime のコンパイル結果を共有し、独立した設定を持ちます。
+Go の呼び出し直列化・キャンセル規則は各 instance に適用され、Runtime の解放で全 instance を閉じます。
+ネイティブ Rust は `traq_markdown_processing::extraction::Extractor` と
+`rendering::PlainTextRenderer` が `&Document` を借用します。
+
+PlainTextRenderer は spoiler をマスクし、空白を正規化した一行の通知テキストを返します。
+Extractor は参照・添付 ID・引用 ID・埋め込み編集計画と、Markdown 記法を保つ `messageText` を返します。
+参照は文書順・重複・spoiler 内を保持し、コード内の文字列は抽出しません。
+`origin` が空なら traQ のファイル・メッセージ URL を通常の URL として扱います。
+
+## TypeScript / HTML rendering
+
+TypeScript の実装は各パッケージの責務に合わせて配置しています。
+
+| TypeScript package                        | 責務                                                                   |
+| ----------------------------------------- | ---------------------------------------------------------------------- |
+| `@traq-markdown-engine/core`              | 共通 AST 型、HTML handler・Plugin・PresetBuilder、契約検証と生成の基盤 |
+| `@traq-markdown-engine/commonmark-plugin` | CommonMark・汎用拡張の生成ノード型と HTML 描画                         |
+| `@traq-markdown-engine/traq-plugin`       | traP の生成ノード型・参照・スタンプ等の HTML 描画                      |
+| `@traq-markdown-engine/sdk`               | Wasm / Go / TypeScript 配布、traQ の描画構成・condensed 表示・CSS      |
+
+開発手順は [ルートの README](../../README.md) を参照してください。ルートで `bun install`・`bun run build` を実行すると、4パッケージを依存順にビルドします。`bun run check:package` は4パッケージを pack し、独立した consumer で配布内容を検証します。
+
+AST の共通形は core の `typescript/ast.ts` に一度だけ定義し、SDK の生成 bindings はそれを構文の union で特殊化します。構文の payload は Rust を正として生成し、commonmark-plugin と traq-plugin の `bun run generate:bindings` でそれぞれの契約 crate から再生成できます。
+
+HTML API は `/renderer` サブパスです。traQ は `@traq-markdown-engine/sdk/renderer` の `messageRenderers`、CSS は `@traq-markdown-engine/sdk/index.css` を利用します。
+
+### HTML の利用例
+
+```ts
+import { createRuntime, presets } from '@traq-markdown-engine/sdk'
+import '@traq-markdown-engine/sdk/index.css'
+import { messageRenderers } from '@traq-markdown-engine/sdk/renderer'
+
+const runtime = await createRuntime(wasmBytes)
+const parser = runtime.createParser(presets.traq.v1)
+const view = messageRenderers({ origin: 'https://q.example.test' })
+const document = parser.parse(source)
+const { renderedText, embeddings } = view.standard.render(document)
+const condensed = view.condensed.render(document)
+runtime.dispose()
+```
+
+Wasm の起動は利用側が明示的に行います。`/renderer` を import しても Wasm runtime は読み込みません。描画のカスタマイズは `@traq-markdown-engine/core/renderer` の `Plugin`・`PresetBuilder` と、各構文の `/renderer` を利用します。
+
+## Corpus comparison
+
+Use `bun run corpus:collect`, `bun run corpus:compare`, and `bun run corpus:report` to collect messages and generate offline HTML/MHTML difference reports. See the [corpus comparison tool](../../tools/corpus/README.md) for inputs, options, and output files.
+
+Go consumers use `github.com/uni-kakurenbo/traq-markdown-engine/packages/sdk/go` for presets and artifact pairing. Shared AST/transport live in the core Go module; payload factories live in commonmark-plugin and traq-plugin. `Extractor.Extract` returns source-preserving message text, references, embedding edits, attachment IDs and citation IDs from the supplied Document. `PlainTextRenderer.Render` independently renders that Document for notifications.
+
+Embedding edits are also shared: Rust derives `output.embedding` from the same AST. Pass that plan and an application identity resolver to `embedReferences` (TypeScript) or `EmbedReferences` (Go). `output.embedding.unembeddedText` restores reference labels for copying, and `mentionsUser` checks the extracted references. See [processing presets](crates/processing/README.md) for the editing rules.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,51 @@
+# Algorithm sources
+
+The delimiter pairing in the core package’s `crates/parser/src/engine/inline/delimiters.rs` and emphasis handling
+in the commonmark-plugin package’s `crates/syntax/src/inlines/emphasis.rs` are adapted from
+markdown-it 14.3.0 (`lib/rules_inline/balance_pairs.mjs`, `emphasis.mjs`).
+The spoiler scanner follows @traptitech/markdown-it-spoiler 1.1.6.
+The inline math scanner follows @traptitech/markdown-it-katex 3.6.0.
+Block parsing, reference handling, and HTML recognition follow markdown-it 14.3.0.
+V1 stamp recognition follows @traptitech/traq-markdown-it.
+URL recognition/normalization and the frozen TLD set follow linkify-it 5 and markdown-it 14.3.0.
+
+Copyright (c) 2014 Vitaly Puzrin, Alex Kocharin.
+Copyright (c) 2014-2015 Vitaly Puzrin, Alex Kocharin.
+Copyright (c) 2016 Waylon Flinn.
+Copyright (c) 2018 Takahiro Ethan Ikeuchi @iktakahiro.
+Copyright (c) 2020 traP.
+Copyright (c) 2020 magiclen.org (Ron Li). Entity names from html-escape 0.2.15.
+
+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.
+
+## Entity values
+
+`src/syntax/commonmark/inlines/entities_table.rs` freezes the 2,125 semicolon-terminated names with values decoded
+by the frontend's `entities` 7.0.1. This also preserves multi-codepoint entities.
+
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/contract.json

@@ -0,0 +1,18 @@
+{
+  "buildId": "015d42a01b73e510",
+  "limits": {
+    "inputBytes": 1048576,
+    "memoryBytes": 33554432,
+    "outputBytes": 1048576
+  },
+  "presets": {
+    "commonmark": 0,
+    "traq": {
+      "v1": 1
+    }
+  },
+  "sha256": "3823d4eab050ae3c410c95ce268b6170c75e64918ecd546e04b32c6bca4699b7",
+  "bytes": 1530839,
+  "gzipBytes": 518515,
+  "brotliBytes": 347616
+}

package/dist/embedding.d.ts

@@ -0,0 +1,5 @@
+import type { EmbeddingPlan, LookupKind, References } from './generated/processing.js';
+/** Resolves Rust's ordered AST-derived candidates and preserves all other source bytes. */
+export declare function embedReferences(source: string, plan: EmbeddingPlan, resolve: (kind: LookupKind, name: string) => string | undefined): string;
+/** Uses parsed references, including those inside spoilers but excluding code/math. */
+export declare function mentionsUser(references: References, userId: string, groupIds: readonly string[]): boolean;

package/dist/embedding.js

@@ -0,0 +1,34 @@
+/** Resolves Rust's ordered AST-derived candidates and preserves all other source bytes. */
+export function embedReferences(source, plan, resolve) {
+    const bytes = new TextEncoder().encode(source);
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    let position = 0;
+    let result = '';
+    for (const candidate of plan.candidates) {
+        const { start, end, raw, kind, name } = candidate;
+        if (start < position) {
+            continue;
+        }
+        if (!Number.isSafeInteger(start) ||
+            !Number.isSafeInteger(end) ||
+            start < 0 ||
+            end <= start ||
+            end > bytes.length ||
+            decoder.decode(bytes.subarray(start, end)) !== raw) {
+            throw new Error('Embedding plan does not match source');
+        }
+        const id = resolve(kind, name);
+        if (!id) {
+            continue;
+        }
+        result += decoder.decode(bytes.subarray(position, start));
+        result += '!' + JSON.stringify({ type: kind, raw, id });
+        position = end;
+    }
+    return result + decoder.decode(bytes.subarray(position));
+}
+/** Uses parsed references, including those inside spoilers but excluding code/math. */
+export function mentionsUser(references, userId, groupIds) {
+    return (references.mentions.includes(userId) ||
+        references.groupMentions.some(id => groupIds.includes(id)));
+}

package/dist/generated/artifact.d.ts

@@ -0,0 +1,2 @@
+export declare const buildId = "015d42a01b73e510";
+export declare const inputBytes = 1048576;

package/dist/generated/artifact.js

@@ -0,0 +1,3 @@
+// Generated for this Wasm build. Do not edit.
+export const buildId = '015d42a01b73e510';
+export const inputBytes = 1048576;

package/dist/generated/nodes.d.ts

@@ -0,0 +1,54 @@
+import * as generic from '@traq-markdown-engine/commonmark-plugin/generic/nodes';
+import * as commonmark from '@traq-markdown-engine/commonmark-plugin/nodes';
+import * as trap from '@traq-markdown-engine/traq-plugin/nodes';
+import type { Document as AstDocument, Node as AstNode } from '@traq-markdown-engine/core';
+export type NodeKind = commonmark.NodeKind | generic.NodeKind | trap.NodeKind;
+export type Node<AllowUnknown extends boolean = false> = AstNode<NodeKind | (AllowUnknown extends true ? {
+    kind: string;
+    data: unknown;
+} : never)>;
+export type Document<AllowUnknown extends boolean = false> = AstDocument<NodeKind | (AllowUnknown extends true ? {
+    kind: string;
+    data: unknown;
+} : never)>;
+export declare const names: Readonly<{
+    Mark: 'markdown_generic_contracts::mark::MarkData';
+    BlockMath: 'markdown_generic_contracts::math::BlockMathData';
+    InlineMath: 'markdown_generic_contracts::math::InlineMathData';
+    Strikethrough: 'markdown_generic_contracts::strikethrough::StrikethroughData';
+    Cell: 'markdown_generic_contracts::table::CellData';
+    Row: 'markdown_generic_contracts::table::RowData';
+    Table: 'markdown_generic_contracts::table::TableData';
+    Blockquote: 'markdown_commonmark_contracts::nodes::Blockquote';
+    CodeBlock: 'markdown_commonmark_contracts::nodes::CodeBlock';
+    Emphasis: 'markdown_commonmark_contracts::nodes::Emphasis';
+    Hardbreak: 'markdown_commonmark_contracts::nodes::Hardbreak';
+    Heading: 'markdown_commonmark_contracts::nodes::Heading';
+    HtmlBlock: 'markdown_commonmark_contracts::nodes::HtmlBlock';
+    HtmlInline: 'markdown_commonmark_contracts::nodes::HtmlInline';
+    Image: 'markdown_commonmark_contracts::nodes::Image';
+    InlineCode: 'markdown_commonmark_contracts::nodes::InlineCode';
+    Link: 'markdown_commonmark_contracts::nodes::Link';
+    List: 'markdown_commonmark_contracts::nodes::List';
+    ListItem: 'markdown_commonmark_contracts::nodes::ListItem';
+    Paragraph: 'markdown_commonmark_contracts::nodes::Paragraph';
+    Softbreak: 'markdown_commonmark_contracts::nodes::Softbreak';
+    Strong: 'markdown_commonmark_contracts::nodes::Strong';
+    Text: 'markdown_commonmark_contracts::nodes::Text';
+    ThematicBreak: 'markdown_commonmark_contracts::nodes::ThematicBreak';
+    BlankLine: 'markdown_trap_contracts::compat::BlankLineData';
+    Embedding: 'markdown_trap_contracts::embedding::EmbeddingData';
+    Reference: 'markdown_trap_contracts::reference::ReferenceData';
+    Spoiler: 'markdown_trap_contracts::spoiler::SpoilerData';
+    Stamp: 'markdown_trap_contracts::stamp::StampData';
+}>;
+export declare const nodes: ReadonlyMap<string, (data: unknown) => boolean>;
+export declare function isKnownNode(node: Node<true>): node is Node<true> & NodeKind;
+export type ParseError = {
+    code: 'invalid_utf8';
+} | {
+    code: 'resource_limit';
+    resource: string;
+} | {
+    code: 'internal_error';
+};

package/dist/generated/nodes.js

@@ -0,0 +1,17 @@
+// Generated from Rust contracts. Do not edit.
+import * as generic from '@traq-markdown-engine/commonmark-plugin/generic/nodes';
+import * as commonmark from '@traq-markdown-engine/commonmark-plugin/nodes';
+import * as trap from '@traq-markdown-engine/traq-plugin/nodes';
+export const names = Object.freeze({
+    ...commonmark.names,
+    ...generic.names,
+    ...trap.names
+});
+export const nodes = new Map([
+    ...commonmark.nodes,
+    ...generic.nodes,
+    ...trap.nodes
+]);
+export function isKnownNode(node) {
+    return nodes.get(node.kind)?.(node.data) ?? false;
+}

package/dist/generated/presets.d.ts

@@ -0,0 +1,7 @@
+export type Preset = 'commonmark' | 'traq.v1';
+export declare const presets: {
+    readonly commonmark: 'commonmark';
+    readonly traq: {
+        readonly v1: 'traq.v1';
+    };
+};

package/dist/generated/presets.js

@@ -0,0 +1,4 @@
+export const presets = {
+    commonmark: 'commonmark',
+    traq: { v1: 'traq.v1' }
+};

package/dist/generated/processing.d.ts

@@ -0,0 +1,48 @@
+export type Extraction = {
+    messageText: string;
+    attachments: Array<string>;
+    citations: Array<string>;
+    references: References;
+    embedding: EmbeddingPlan;
+};
+export type EmbeddingPlan = {
+    /**
+     * Ordered lookup attempts. A successful attempt consumes its source range.
+     */
+    candidates: Array<EmbeddingCandidate>;
+    /**
+     * Original Markdown with recognized reference nodes restored to their labels.
+     */
+    unembeddedText: string;
+};
+export type EmbeddingCandidate = {
+    /**
+     * UTF-8 byte offsets into the original source, not rendered text.
+     */
+    start: number;
+    end: number;
+    raw: string;
+    name: string;
+    kind: LookupKind;
+};
+export type LookupKind = 'user' | 'group' | 'channel';
+export type References = {
+    mentions: Array<string>;
+    groupMentions: Array<string>;
+    channelLinks: Array<string>;
+    embeddings: Array<EmbeddedInfo>;
+};
+export type EmbeddedInfo = {
+    raw: string;
+    type: string;
+    id: string;
+};
+export type ExtractorOptions = {
+    /**
+     * Origin used to recognize traQ file/message URLs; empty leaves URLs as text.
+     */
+    origin: string;
+};
+export type RendererOptions = {
+    origin: string;
+};

package/dist/generated/processing.js

@@ -0,0 +1 @@
+export {};