:`.
+ const string Prefix = "anydoc:";
+ string text = e.Message;
+ if (text.StartsWith(Prefix, StringComparison.Ordinal))
+ {
+ string rest = text[Prefix.Length..];
+ int colon = rest.IndexOf(':');
+ if (colon > 0)
+ {
+ return AnydocException.From(rest[..colon], rest[(colon + 1)..]);
+ }
+ }
+ return AnydocException.From("unknown", text);
+ }
+
+ /// The name the wasm-bindgen enum uses for a format (the JS
+ /// string enum is what crosses the boundary, not the ordinal).
+ private static string? FormatToWasmName(Format? format) => format switch
+ {
+ null => null,
+ Format.Doc => "doc",
+ Format.Docx => "docx",
+ Format.Odt => "odt",
+ Format.Pdf => "pdf",
+ Format.Ppt => "ppt",
+ Format.Pptx => "pptx",
+ Format.Rtf => "rtf",
+ Format.Epub => "epub",
+ Format.Excel => "xlsx",
+ Format.Ods => "ods",
+ Format.Odp => "odp",
+ Format.Csv => "csv",
+ _ => null,
+ };
+
+ private static Format? FormatFromWasmName(string? name) => name switch
+ {
+ "doc" => Format.Doc,
+ "docx" => Format.Docx,
+ "odt" => Format.Odt,
+ "pdf" => Format.Pdf,
+ "ppt" => Format.Ppt,
+ "pptx" => Format.Pptx,
+ "rtf" => Format.Rtf,
+ "epub" => Format.Epub,
+ "xlsx" => Format.Excel,
+ "ods" => Format.Ods,
+ "odp" => Format.Odp,
+ "csv" => Format.Csv,
+ _ => null,
+ };
+
+ /// Release the JavaScript module reference. Idempotent; the
+ /// converter is unusable afterwards.
+ public async ValueTask DisposeAsync()
+ {
+ if (_module is not null)
+ {
+ await _module.DisposeAsync();
+ _module = null;
+ }
+ }
+}
\ No newline at end of file
diff --git a/dotnet/Firecrawl.Anydoc.Wasm/Firecrawl.Anydoc.Wasm.csproj b/dotnet/Firecrawl.Anydoc.Wasm/Firecrawl.Anydoc.Wasm.csproj
new file mode 100644
index 00000000..e6447b6b
--- /dev/null
+++ b/dotnet/Firecrawl.Anydoc.Wasm/Firecrawl.Anydoc.Wasm.csproj
@@ -0,0 +1,49 @@
+
+
+
+ net8.0
+ enable
+ enable
+ latest
+
+ Firecrawl.Anydoc.Wasm
+ Firecrawl.Anydoc
+
+ 0.1.7
+ WebAssembly binding for anydoc: convert documents (doc, docx, odt, rtf, epub, pdf, presentations, spreadsheets, csv) to GitHub-Flavored Markdown inside a Blazor WebAssembly app, without any native platform library.
+ Firecrawl.Anydoc.Wasm
+ Firecrawl;Junian Triajianto
+ Firecrawl;junian
+ MIT
+ https://github.com/firecrawl/anydoc
+ https://github.com/firecrawl/anydoc
+ markdown; docx; pptx; xlsx; epub; pdf; converter; blazor; wasm; document
+ README.md
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/dotnet/Firecrawl.Anydoc.Wasm/wwwroot/anydoc-wasm.js b/dotnet/Firecrawl.Anydoc.Wasm/wwwroot/anydoc-wasm.js
new file mode 100644
index 00000000..de014028
--- /dev/null
+++ b/dotnet/Firecrawl.Anydoc.Wasm/wwwroot/anydoc-wasm.js
@@ -0,0 +1,65 @@
+// Firecrawl.Anydoc.Wasm interop shim.
+//
+// Loaded once from managed code via Blazor's `import` helper. It lazy-loads
+// the wasm-bindgen glue produced from the anydoc `wasm/` crate, instantiates
+// the engine, and re-exposes the conversion entry points as plain functions
+// that the C# AnydocConverter calls through IJSRuntime.
+//
+// Conversion errors thrown by the engine (a JS Error with a `code` property)
+// are re-thrown with a parseable `anydoc::` message so the
+// managed side can reconstruct an AnydocException with the right Kind.
+
+let gluePromise = null;
+
+function glue() {
+ if (!gluePromise) {
+ gluePromise = (async () => {
+ const m = await import("./anydoc_wasm.js");
+ // The wasm binary sits next to this shim; resolve it against
+ // import.meta.url, not the app's base path.
+ const wasmUrl = new URL("./anydoc_wasm_bg.wasm", import.meta.url);
+ await m.default(wasmUrl);
+ return m;
+ })();
+ }
+ return gluePromise;
+}
+
+function rethrowConversion(error) {
+ const code = (error && error.code) || "unknown";
+ const message = (error && error.message) || String(error);
+ throw new Error(`anydoc:${code}:${message}`);
+}
+
+export async function formatFromBytes(bytes) {
+ const m = await glue();
+ return m.formatFromBytes(bytes);
+}
+
+export async function formatFromExtension(extension) {
+ const m = await glue();
+ return m.formatFromExtension(extension);
+}
+
+export async function formatFromPath(path) {
+ const m = await glue();
+ return m.formatFromPath(path);
+}
+
+export async function toMarkdownBytes(bytes, format) {
+ const m = await glue();
+ try {
+ return m.toMarkdownBytes(bytes, format || undefined);
+ } catch (error) {
+ throw rethrowConversion(error);
+ }
+}
+
+export async function toDocument(bytes, format) {
+ const m = await glue();
+ try {
+ return m.toDocument(bytes, format || undefined);
+ } catch (error) {
+ throw rethrowConversion(error);
+ }
+}
\ No newline at end of file
diff --git a/dotnet/Firecrawl.Anydoc.slnx b/dotnet/Firecrawl.Anydoc.slnx
new file mode 100644
index 00000000..9741466a
--- /dev/null
+++ b/dotnet/Firecrawl.Anydoc.slnx
@@ -0,0 +1,14 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/dotnet/Firecrawl.Anydoc/AnydocConverter.cs b/dotnet/Firecrawl.Anydoc/AnydocConverter.cs
new file mode 100644
index 00000000..741fc29a
--- /dev/null
+++ b/dotnet/Firecrawl.Anydoc/AnydocConverter.cs
@@ -0,0 +1,177 @@
+using System.Runtime.InteropServices;
+using System.Text;
+using Firecrawl.Anydoc.Native;
+using Firecrawl.Anydoc.Model;
+
+namespace Firecrawl.Anydoc;
+
+/// Converts documents to GitHub-Flavored Markdown, backed by the anydoc
+/// Rust engine loaded as a native library. Safe to share across threads and
+/// reuse: the underlying native calls are stateless, so instances hold no
+/// process-lifetime resources and do not need to be disposed.
+public sealed class AnydocConverter
+{
+ private const int NoFormat = -1;
+
+ /// Detect the format from the content itself: the signature and
+ /// identity each container specification designates (PDF header, RTF open
+ /// group, OLE stream names, ZIP package mimetype/content types). Plain-text
+ /// formats (CSV) carry no signature and return
+ public unsafe Format? DetectFormat(ReadOnlySpan bytes)
+ {
+ unsafe
+ {
+ fixed (byte* p = bytes)
+ {
+ return FormatFromCode(AnydocNative.anydoc_format_from_bytes(p, (nuint)bytes.Length));
+ }
+ }
+ }
+
+ /// The format an extension names, with or without a leading
+ /// dot.
+ public unsafe Format? DetectFormatByExtension(string extension)
+ {
+ byte[] text = Encoding.UTF8.GetBytes(extension);
+ unsafe
+ {
+ fixed (byte* p = text)
+ {
+ return FormatFromCode(AnydocNative.anydoc_format_from_extension(p, (nuint)text.Length));
+ }
+ }
+ }
+
+ /// The format a path's extension names.
+ public unsafe Format? DetectFormatByPath(string path)
+ {
+ byte[] text = Encoding.UTF8.GetBytes(path);
+ unsafe
+ {
+ fixed (byte* p = text)
+ {
+ return FormatFromCode(AnydocNative.anydoc_format_from_path(p, (nuint)text.Length));
+ }
+ }
+ }
+
+ /// Convert a document file to Markdown. The format is detected from
+ /// the file content; the extension is the fallback for signature-less
+ /// formats (CSV) and unrecognizable containers.
+ /// when conversion is impossible; a file
+ /// that cannot be read has
+ public unsafe string ToMarkdown(string path)
+ {
+ byte[] text = Encoding.UTF8.GetBytes(path);
+ AnyResult result = default;
+ unsafe
+ {
+ fixed (byte* p = text)
+ {
+ AnydocNative.anydoc_to_markdown_path(p, (nuint)text.Length, &result);
+ }
+ }
+ byte[] data = TakeResult(&result);
+ return Encoding.UTF8.GetString(data);
+ }
+
+ /// Asynchronous
+ public Task ToMarkdownAsync(string path) => Task.Run(() => ToMarkdown(path));
+
+ /// Convert an in-memory document to Markdown. Without a format, it is
+ /// detected from the content, which signature-less formats (CSV) have to
+ /// name explicitly.
+ public string ToMarkdownBytes(ReadOnlySpan data) => ToMarkdownBytesCore(data, null);
+
+ /// Convert an in-memory document to Markdown, naming the format
+ /// explicitly.
+ public string ToMarkdownBytes(ReadOnlySpan data, Format format) =>
+ ToMarkdownBytesCore(data, format);
+
+ /// Asynchronous
+ public Task ToMarkdownBytesAsync(ReadOnlySpan data)
+ {
+ byte[] copy = data.ToArray();
+ return Task.Run(() => ToMarkdownBytes(copy));
+ }
+
+ /// Asynchronous
+ public Task ToMarkdownBytesAsync(ReadOnlySpan data, Format format)
+ {
+ byte[] copy = data.ToArray();
+ return Task.Run(() => ToMarkdownBytes(copy, format));
+ }
+
+ /// Parse an in-memory document into the document model, which also
+ /// carries the embedded assets. The format is detected from the content.
+ /// Unsupported for
+ public unsafe Document ToDocument(ReadOnlySpan bytes)
+ {
+ AnyResult result = default;
+ unsafe
+ {
+ fixed (byte* p = bytes)
+ {
+ AnydocNative.anydoc_to_document(p, (nuint)bytes.Length, NoFormat, &result);
+ }
+ }
+ byte[] data = TakeResult(&result);
+ return Document.FromJson(Encoding.UTF8.GetString(data));
+ }
+
+ /// Asynchronous
+ public Task ToDocumentAsync(ReadOnlySpan bytes)
+ {
+ byte[] copy = bytes.ToArray();
+ return Task.Run(() => ToDocument(copy));
+ }
+
+ private static unsafe string ToMarkdownBytesCore(ReadOnlySpan data, Format? format)
+ {
+ AnyResult result = default;
+ unsafe
+ {
+ fixed (byte* p = data)
+ {
+ AnydocNative.anydoc_to_markdown_bytes(p, (nuint)data.Length, CodeFor(format), &result);
+ }
+ }
+ byte[] bytes = TakeResult(&result);
+ return Encoding.UTF8.GetString(bytes);
+ }
+
+ private static int CodeFor(Format? format) => format is null ? NoFormat : (int)format;
+
+ private static Format? FormatFromCode(int code) => code < 0 ? null : (Format)code;
+
+ /// Turn a filled
+ private static unsafe byte[] TakeResult(AnyResult* result)
+ {
+ try
+ {
+ if (!result->ok)
+ {
+ string? code = Marshal.PtrToStringUTF8((nint)result->error_code);
+ string? message = Marshal.PtrToStringUTF8((nint)result->error_message);
+ throw AnydocException.From(code, message);
+ }
+ byte[] data = new byte[(int)result->data.len];
+ if (data.Length > 0)
+ {
+ Marshal.Copy((nint)result->data.ptr, data, 0, data.Length);
+ }
+ return data;
+ }
+ finally
+ {
+ AnydocNative.anydoc_free_result(result);
+ }
+ }
+}
diff --git a/dotnet/Firecrawl.Anydoc/Firecrawl.Anydoc.csproj b/dotnet/Firecrawl.Anydoc/Firecrawl.Anydoc.csproj
new file mode 100644
index 00000000..abbd7820
--- /dev/null
+++ b/dotnet/Firecrawl.Anydoc/Firecrawl.Anydoc.csproj
@@ -0,0 +1,53 @@
+
+
+
+ net8.0
+ enable
+ enable
+ true
+ latest
+
+ Firecrawl.Anydoc
+ Firecrawl.Anydoc
+
+ 0.1.7
+ Convert documents (doc, docx, odt, rtf, epub, pdf, presentations, spreadsheets, csv) to GitHub-Flavored Markdown, backed by the anydoc Rust engine.
+ Firecrawl.Anydoc
+ Firecrawl;Junian Triajianto
+ Firecrawl;junian
+ MIT
+ https://github.com/firecrawl/anydoc
+ https://github.com/firecrawl/anydoc
+ markdown; docx; pptx; xlsx; epub; pdf; converter; document
+ README.md
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/dotnet/Firecrawl.Anydoc/NativeMethods.cs b/dotnet/Firecrawl.Anydoc/NativeMethods.cs
new file mode 100644
index 00000000..199fc4f2
--- /dev/null
+++ b/dotnet/Firecrawl.Anydoc/NativeMethods.cs
@@ -0,0 +1,60 @@
+using System.Runtime.InteropServices;
+
+namespace Firecrawl.Anydoc.Native
+{
+ ///
+ /// DllImport surface, extended with the platform-specific loader that maps
+ /// the logical library name to runtimes/{platform}-{arch}/native/ ,
+ /// the layout both NuGet and this project's build output use.
+ ///
+ internal static unsafe partial class AnydocNative
+ {
+ static AnydocNative()
+ {
+ NativeLibrary.SetDllImportResolver(typeof(AnydocNative).Assembly, ResolveLibrary);
+ }
+
+ private static nint ResolveLibrary(string libraryName, System.Reflection.Assembly assembly, DllImportSearchPath? searchPath)
+ {
+ if (libraryName != __DllName)
+ {
+ return nint.Zero;
+ }
+
+ string platform = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "win"
+ : RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? "osx"
+ : RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "linux"
+ : throw new PlatformNotSupportedException($"anydoc has no native library for {RuntimeInformation.OSDescription}");
+
+ string arch = RuntimeInformation.OSArchitecture switch
+ {
+ Architecture.X64 => "x64",
+ Architecture.Arm64 => "arm64",
+ _ => throw new PlatformNotSupportedException($"anydoc has no native library for {RuntimeInformation.OSArchitecture}"),
+ };
+
+ string name = libraryName;
+ string prefix = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "" : "lib";
+ string ext = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".dll"
+ : RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? ".dylib"
+ : ".so";
+
+ string relative = $"runtimes/{platform}-{arch}/native/{prefix}{name}{ext}";
+ foreach (string baseDir in new[] { AppContext.BaseDirectory, Path.GetDirectoryName(typeof(AnydocNative).Assembly.Location) ?? "" })
+ {
+ if (string.IsNullOrEmpty(baseDir))
+ {
+ continue;
+ }
+ string candidate = Path.Combine(baseDir, relative);
+ if (File.Exists(candidate))
+ {
+ return NativeLibrary.Load(candidate, assembly, searchPath);
+ }
+ }
+ // Last chance: let the default resolution attempt it (NuGet hosts
+ // native libs on the default search path too).
+ return NativeLibrary.Load(relative, assembly, searchPath);
+ }
+ }
+}
diff --git a/dotnet/Firecrawl.Anydoc/NativeMethods.g.cs b/dotnet/Firecrawl.Anydoc/NativeMethods.g.cs
new file mode 100644
index 00000000..2737ebee
--- /dev/null
+++ b/dotnet/Firecrawl.Anydoc/NativeMethods.g.cs
@@ -0,0 +1,102 @@
+//
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+//
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace Firecrawl.Anydoc.Native
+{
+ internal static unsafe partial class AnydocNative
+ {
+ const string __DllName = "anydoc_dotnet";
+
+
+
+
+
+ ///
+ /// `format_from_bytes`: detect the format from content.
+ ///
+ [DllImport(__DllName, EntryPoint = "anydoc_format_from_bytes", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+ internal static extern int anydoc_format_from_bytes(byte* bytes, nuint len);
+
+ ///
+ /// `format_from_extension`: the format a (possibly dot-prefixed) extension names.
+ ///
+ [DllImport(__DllName, EntryPoint = "anydoc_format_from_extension", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+ internal static extern int anydoc_format_from_extension(byte* bytes, nuint len);
+
+ ///
+ /// `format_from_path`: the format a path's extension names.
+ ///
+ [DllImport(__DllName, EntryPoint = "anydoc_format_from_path", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+ internal static extern int anydoc_format_from_path(byte* bytes, nuint len);
+
+ ///
+ /// `to_markdown(path)`: convert a file, detecting the format from its content.
+ ///
+ [DllImport(__DllName, EntryPoint = "anydoc_to_markdown_path", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+ internal static extern void anydoc_to_markdown_path(byte* path, nuint len, AnyResult* result);
+
+ ///
+ /// `to_markdown_bytes`: convert in-memory bytes; `format` of `-1` detects it.
+ ///
+ [DllImport(__DllName, EntryPoint = "anydoc_to_markdown_bytes", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+ internal static extern void anydoc_to_markdown_bytes(byte* bytes, nuint len, int format, AnyResult* result);
+
+ ///
+ /// `to_document`: parse in-memory bytes into the document model, returned as
+ /// JSON. Unsupported for PDF, like the other bindings.
+ ///
+ [DllImport(__DllName, EntryPoint = "anydoc_to_document", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+ internal static extern void anydoc_to_document(byte* bytes, nuint len, int format, AnyResult* result);
+
+ ///
+ /// Release everything `*result` holds: the error strings and the data buffer.
+ ///
+ [DllImport(__DllName, EntryPoint = "anydoc_free_result", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+ internal static extern void anydoc_free_result(AnyResult* result);
+
+
+ }
+
+ ///
+ /// An owned byte buffer; `ptr` is null and `len` zero when empty.
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ internal unsafe partial struct ByteBuffer
+ {
+ public byte* ptr;
+ public nuint len;
+ public nuint capacity;
+ }
+
+ ///
+ /// The outcome of a conversion. `ok` selects between the payload and the error
+ /// fields; the caller hands the whole struct back to [`anydoc_free_result`].
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ internal unsafe partial struct AnyResult
+ {
+ [MarshalAs(UnmanagedType.U1)] public bool ok;
+ ///
+ /// Machine-readable kind (`error.code()`), null when `ok`.
+ ///
+ public byte* error_code;
+ ///
+ /// Human-readable message, null when `ok`.
+ ///
+ public byte* error_message;
+ ///
+ /// Markdown, or the document model as JSON, when `ok`.
+ ///
+ public ByteBuffer data;
+ }
+
+
+
+}
diff --git a/dotnet/README.md b/dotnet/README.md
new file mode 100644
index 00000000..4a3b7525
--- /dev/null
+++ b/dotnet/README.md
@@ -0,0 +1,140 @@
+# Firecrawl.Anydoc
+
+.NET bindings for **anydoc**, the fast Rust library that converts documents
+(Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, CSV, and PDF) into clean
+GitHub-Flavored Markdown. This package bundles the native engine for every
+supported platform, so it installs and runs with no extra setup.
+
+```
+dotnet add package Firecrawl.Anydoc
+```
+
+Supported platforms: **macOS, Windows, and Linux** on both **x64** and **arm64**.
+
+## Usage
+
+```csharp
+using Firecrawl.Anydoc;
+
+// Construct once and reuse for every conversion.
+// Instances are thread-safe and hold no disposable state.
+var anydoc = new AnydocConverter();
+
+// From a file path (format detected from the content):
+string markdown = await anydoc.ToMarkdownAsync("report.docx");
+
+// From bytes, with the format detected from the content:
+string fromBytes = await anydoc.ToMarkdownBytesAsync(bytes);
+
+// Or name it, which signature-less formats (CSV) need:
+string fromCsv = await anydoc.ToMarkdownBytesAsync(bytes, Format.Csv);
+
+// Or stop at the document model, which also carries embedded assets:
+Document document = await anydoc.ToDocumentAsync(bytes);
+```
+
+Synchronous variants (`ToMarkdown`, `ToMarkdownBytes`, `ToDocument`) behave the
+same way when you are not in an `async` context.
+
+### Format detection
+
+```csharp
+Format? byBytes = anydoc.DetectFormat(bytes); // content signature
+Format? byExt = anydoc.DetectFormatByExtension(".pptm"); // => Format.Pptx
+Format? byPath = anydoc.DetectFormatByPath("sheet.csv"); // => Format.Csv
+```
+
+### Errors
+
+Failures throw `AnydocException`, whose `Kind` (a `ConvertErrorKind`) names the
+reason the same way the Node and Python bindings do:
+
+```csharp
+try
+{
+ string md = anydoc.ToMarkdown(bytes, Format.Docx);
+}
+catch (AnydocException e)
+{
+ switch (e.Kind)
+ {
+ case ConvertErrorKind.Unsupported: // scanned PDF, unknown format
+ case ConvertErrorKind.Malformed: // structurally unusable document
+ case ConvertErrorKind.Encrypted: // password-protected
+ case ConvertErrorKind.ResourceLimit:// a fixed safety limit was crossed
+ case ConvertErrorKind.MissingPart: // a required part is absent
+ case ConvertErrorKind.Io: // the file could not be read
+ }
+}
+```
+
+The document model (`Firecrawl.Anydoc.Model`) encodes every block, inline,
+list, table grid, note, and embedded asset, mirroring the Node and Python
+bindings exactly (`Kind` string discriminants, `NoteId`, `MediaType`, etc.).
+
+## Blazor WebAssembly: `Firecrawl.Anydoc.Wasm`
+
+For client-side Blazor there is a sibling package, `Firecrawl.Anydoc.Wasm`,
+that runs the same engine compiled to WebAssembly. No native library is
+loaded, so a `browser-wasm` publish needs no RID-specific runtime: the engine
+ships as static web assets next to the managed wrapper.
+
+```csharp
+using Firecrawl.Anydoc;
+using Microsoft.JSInterop;
+
+// Injected into a Blazor component or service:
+var anydoc = new AnydocConverter(jsRuntime);
+
+// A browser has no filesystem, so conversion always starts from bytes and
+// every call is async (Blazor WASM has no synchronous JS interop):
+byte[] bytes = await httpClient.GetByteArrayAsync("report.docx");
+string markdown = await anydoc.ToMarkdownBytesAsync(bytes);
+Document document = await anydoc.ToDocumentAsync(bytes);
+
+Format? format = await anydoc.DetectFormatAsync(bytes);
+```
+
+One converter instance is enough for the whole app: it instantiates the WASM
+module lazily and caches it. The API matches the native package — `Format`,
+`ConvertErrorKind`, `AnydocException`, and the `Firecrawl.Anydoc.Model` types
+are the same shared source — but the sync-named members (`ToMarkdownBytes`,
+`ToDocument`, `DetectFormat`, ...) throw `PlatformNotSupportedException`
+because Blazor WASM cannot block on JavaScript interop.
+
+### Building the WebAssembly engine
+
+The compiled assets are gitignored and produced from the `wasm/` crate:
+
+```sh
+sh dotnet/build-wasm.sh # needs the wasm32-unknown-unknown target and wasm-pack
+```
+
+This writes `anydoc_wasm.js` (wasm-bindgen glue) and `anydoc_wasm_bg.wasm`
+into `Firecrawl.Anydoc.Wasm/wwwroot/`, which the package ships as static web
+assets. `wwwroot/anydoc-wasm.js` — the small interop shim the managed wrapper
+loads via Blazor's `import` — is checked in and never regenerated.
+
+## Building
+
+The C# wrapper is generated from the Rust FFI with
+[csbindgen](https://github.com/Cysharp/csbindgen): `cargo build -p anydoc-dotnet`
+regenerates `src/NativeMethods.g.cs`.
+
+To rebuild the native binaries and produce the NuGet package:
+
+```sh
+sh dotnet/build.sh # build the host's native library and pack
+sh dotnet/build.sh --all # build every supported platform's library
+```
+
+Each architecture's library is laid out under
+`src/runtimes/{rid}/native/` — NuGet's native-library convention — so a single
+package carries all six targets. `dotnet pack` bundles them with the managed
+wrapper.
+
+Run the tests with:
+
+```sh
+dotnet test dotnet/Firecrawl.Anydoc.slnx
+```
\ No newline at end of file
diff --git a/dotnet/build-wasm.sh b/dotnet/build-wasm.sh
new file mode 100755
index 00000000..9ef3a3d3
--- /dev/null
+++ b/dotnet/build-wasm.sh
@@ -0,0 +1,47 @@
+#!/bin/sh
+# Build the anydoc WASM engine from the repo's wasm/ crate and lay the
+# wasm-bindgen output into Firecrawl.Anydoc.Wasm/wwwroot so the NuGet package
+# ships them as static web assets.
+#
+# Produces:
+# Firecrawl.Anydoc.Wasm/wwwroot/anydoc_wasm.js wasm-bindgen glue
+# Firecrawl.Anydoc.Wasm/wwwroot/anydoc_wasm_bg.wasm engine binary
+#
+# The static wwwroot/anydoc-wasm.js interop shim is checked in (not generated).
+#
+# Prerequisites:
+# rustup target add wasm32-unknown-unknown
+# cargo install wasm-pack (or use the wasm-bindgen CLI directly)
+set -eu
+
+cd "$(dirname "$0")"
+root=$(pwd)
+wasm_dir="$root/../wasm"
+out="$root/Firecrawl.Anydoc.Wasm/wwwroot"
+
+build_with_wasm_pack() {
+ (cd "$wasm_dir" && wasm-pack build --release --target web --out-dir pkg)
+ cp "$wasm_dir/pkg/anydoc_wasm.js" "$out/anydoc_wasm.js"
+ cp "$wasm_dir/pkg/anydoc_wasm_bg.wasm" "$out/anydoc_wasm_bg.wasm"
+}
+
+build_with_wasm_bindgen() {
+ rustup target add wasm32-unknown-unknown >/dev/null
+ (cd "$wasm_dir" && cargo build --release --target wasm32-unknown-unknown --package anydoc-wasm)
+ wasm-bindgen "$root/../target/wasm32-unknown-unknown/release/anydoc_wasm.wasm" \
+ --target web --out-dir "$out" --out-name anydoc_wasm
+}
+
+rm -f "$out/anydoc_wasm.js" "$out/anydoc_wasm_bg.wasm"
+if command -v wasm-pack >/dev/null 2>&1; then
+ build_with_wasm_pack
+elif command -v wasm-bindgen >/dev/null 2>&1; then
+ build_with_wasm_bindgen
+else
+ echo "no wasm-pack or wasm-bindgen toolchain found." >&2
+ echo "install one: cargo install wasm-pack (or cargo install wasm-bindgen-cli)" >&2
+ exit 1
+fi
+
+echo "-> $out/anydoc_wasm.js"
+echo "-> $out/anydoc_wasm_bg.wasm"
\ No newline at end of file
diff --git a/dotnet/build.sh b/dotnet/build.sh
new file mode 100755
index 00000000..a316fa74
--- /dev/null
+++ b/dotnet/build.sh
@@ -0,0 +1,79 @@
+#!/bin/sh
+# Build the native cdylib for the listed targets and lay each one out under
+# dotnet/Firecrawl.Anydoc/runtimes/{rid}/native so `dotnet pack` bundles a NuGet package
+# (Firecrawl.Anydoc) that carries macOS, Windows, and Linux binaries for both
+# x64 and arm64.
+#
+# Cross-compiling to a target you do not natively develop on needs that target
+# installed (`rustup target add `). Windows/MSVC targets cannot be
+# produced on macOS or Linux hosts; build those on Windows runners.
+#
+# Usage (from the repo root, or dotnet/):
+# sh dotnet/build.sh # host target only
+# sh dotnet/build.sh --all # every supported native target
+# sh dotnet/build.sh osx-arm64 ... # a specific RID subset
+set -eu
+
+cd "$(dirname "$0")"
+root=$(pwd)
+repo=$(cd .. && pwd)
+
+# RID -> rust target triple -> artifact filename
+# (cargo names cdylibs lib.dylib/.so and .dll on their platforms)
+targets() {
+ echo osx-x64:x86_64-apple-darwin:libanydoc_dotnet.dylib
+ echo osx-arm64:aarch64-apple-darwin:libanydoc_dotnet.dylib
+ echo win-x64:x86_64-pc-windows-msvc:anydoc_dotnet.dll
+ echo win-arm64:aarch64-pc-windows-msvc:anydoc_dotnet.dll
+ echo linux-x64:x86_64-unknown-linux-gnu:libanydoc_dotnet.so
+ echo linux-arm64:aarch64-unknown-linux-gnu:libanydoc_dotnet.so
+}
+
+host_rid() {
+ case "$(uname -s)-$(uname -m)" in
+ Darwin-arm64) echo osx-arm64 ;;
+ Darwin-x86_64|Darwin-i386) echo osx-x64 ;;
+ Linux-x86_64|Linux-amd64) echo linux-x64 ;;
+ Linux-aarch64|Linux-arm64) echo linux-arm64 ;;
+ *) echo "unsupported host $(uname -s) $(uname -m)" >&2; exit 2 ;;
+ esac
+}
+
+build_rid() {
+ rid=$1; shift
+ line=$(targets | grep "^$rid:" || true)
+ [ -n "$line" ] || { echo "unknown RID: $rid" >&2; exit 2; }
+ rest=${line#*:} # strip rid
+ triple=${rest%%:*} # rust target triple
+ artifact=${rest#*:} # cdylib filename
+
+ echo "-- building $rid ($triple)"
+ if [ "$triple" = unknown ] || ! rustup target list --installed 2>/dev/null | grep -qx "$triple"; then
+ echo " target $triple not installed; skipping (add it with: rustup target add $triple)" >&2
+ return 1
+ fi
+ cargo build --manifest-path "$root/native/Cargo.toml" --release --target "$triple" -p anydoc-dotnet
+
+ out=$(find "$root/../target" "$root/native/target" -type f -name "$artifact" 2>/dev/null | head -n 1)
+ [ -n "$out" ] || { echo " artifact $artifact not found" >&2; return 1; }
+ mkdir -p "$root/Firecrawl.Anydoc/runtimes/$rid/native"
+ cp "$out" "$root/Firecrawl.Anydoc/runtimes/$rid/native/$artifact"
+ echo " -> dotnet/Firecrawl.Anydoc/runtimes/$rid/native/$artifact"
+}
+
+if [ "$#" -eq 0 ]; then
+ build_rid "$(host_rid)"
+elif [ "$1" = --all ]; then
+ for rid in $(targets | cut -d: -f1); do
+ build_rid "$rid" || true
+ done
+else
+ for rid in "$@"; do
+ build_rid "$rid"
+ done
+fi
+
+echo "--packing dotnet"
+dotnet pack "$root/Firecrawl.Anydoc/Firecrawl.Anydoc.csproj" -c Release -o "$root/artifacts"
+echo "package:"
+ls -1 "$root/artifacts"/Firecrawl.Anydoc.*.nupkg 2>/dev/null || true
\ No newline at end of file
diff --git a/dotnet/examples/AnydocAvaloniaDemo/AnydocAvaloniaDemo.csproj b/dotnet/examples/AnydocAvaloniaDemo/AnydocAvaloniaDemo.csproj
new file mode 100644
index 00000000..0f1550cb
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/AnydocAvaloniaDemo.csproj
@@ -0,0 +1,29 @@
+
+
+ WinExe
+ net10.0
+ enable
+ app.manifest
+
+
+
+
+
+
+
+
+
+
+ None
+ All
+
+
+
diff --git a/dotnet/examples/AnydocAvaloniaDemo/App.axaml b/dotnet/examples/AnydocAvaloniaDemo/App.axaml
new file mode 100644
index 00000000..c8f723c1
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/App.axaml
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/dotnet/examples/AnydocAvaloniaDemo/App.axaml.cs b/dotnet/examples/AnydocAvaloniaDemo/App.axaml.cs
new file mode 100644
index 00000000..625edfd7
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/App.axaml.cs
@@ -0,0 +1,28 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Markup.Xaml;
+using AnydocAvaloniaDemo.ViewModels;
+using AnydocAvaloniaDemo.Views;
+
+namespace AnydocAvaloniaDemo;
+
+public partial class App : Application
+{
+ public override void Initialize()
+ {
+ AvaloniaXamlLoader.Load(this);
+ }
+
+ public override void OnFrameworkInitializationCompleted()
+ {
+ if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+ {
+ desktop.MainWindow = new MainWindow
+ {
+ DataContext = new MainViewModel(),
+ };
+ }
+
+ base.OnFrameworkInitializationCompleted();
+ }
+}
\ No newline at end of file
diff --git a/dotnet/examples/AnydocAvaloniaDemo/Assets/avalonia-logo.ico b/dotnet/examples/AnydocAvaloniaDemo/Assets/avalonia-logo.ico
new file mode 100644
index 00000000..f7da8bb5
Binary files /dev/null and b/dotnet/examples/AnydocAvaloniaDemo/Assets/avalonia-logo.ico differ
diff --git a/dotnet/examples/AnydocAvaloniaDemo/Program.cs b/dotnet/examples/AnydocAvaloniaDemo/Program.cs
new file mode 100644
index 00000000..b0d03561
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/Program.cs
@@ -0,0 +1,24 @@
+using Avalonia;
+using System;
+
+namespace AnydocAvaloniaDemo;
+
+sealed class Program
+{
+ // Initialization code. Don't use any Avalonia, third-party APIs or any
+ // SynchronizationContext-reliant code before AppMain is called: things aren't initialized
+ // yet and stuff might break.
+ [STAThread]
+ public static void Main(string[] args) => BuildAvaloniaApp()
+ .StartWithClassicDesktopLifetime(args);
+
+ // Avalonia configuration, don't remove; also used by visual designer.
+ public static AppBuilder BuildAvaloniaApp()
+ => AppBuilder.Configure()
+ .UsePlatformDetect()
+#if DEBUG
+ .WithDeveloperTools()
+#endif
+ .WithInterFont()
+ .LogToTrace();
+}
diff --git a/dotnet/examples/AnydocAvaloniaDemo/ViewLocator.cs b/dotnet/examples/AnydocAvaloniaDemo/ViewLocator.cs
new file mode 100644
index 00000000..104e53d3
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/ViewLocator.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Avalonia.Controls;
+using Avalonia.Controls.Templates;
+using AnydocAvaloniaDemo.ViewModels;
+
+namespace AnydocAvaloniaDemo;
+
+///
+/// Given a view model, returns the corresponding view if possible.
+///
+[RequiresUnreferencedCode(
+ "Default implementation of ViewLocator involves reflection which may be trimmed away.",
+ Url = "https://docs.avaloniaui.net/docs/concepts/view-locator")]
+public class ViewLocator : IDataTemplate
+{
+ public Control? Build(object? param)
+ {
+ if (param is null)
+ return null;
+
+ var name = param.GetType().FullName!.Replace("ViewModel", "View", StringComparison.Ordinal);
+ var type = Type.GetType(name);
+
+ if (type != null)
+ {
+ return (Control)Activator.CreateInstance(type)!;
+ }
+
+ return new TextBlock { Text = "Not Found: " + name };
+ }
+
+ public bool Match(object? data)
+ {
+ return data is ViewModelBase;
+ }
+}
diff --git a/dotnet/examples/AnydocAvaloniaDemo/ViewModels/MainViewModel.cs b/dotnet/examples/AnydocAvaloniaDemo/ViewModels/MainViewModel.cs
new file mode 100644
index 00000000..824dacae
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/ViewModels/MainViewModel.cs
@@ -0,0 +1,91 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Firecrawl.Anydoc;
+
+namespace AnydocAvaloniaDemo.ViewModels;
+
+public partial class MainViewModel : ViewModelBase
+{
+ private readonly AnydocConverter _converter = new();
+
+ [ObservableProperty]
+ public partial string SelectedFile { get; set; } = "";
+
+ [ObservableProperty]
+ public partial string Status { get; set; } = "Select a document to convert.";
+
+ [ObservableProperty]
+ public partial string Markdown { get; set; } = "";
+
+ [ObservableProperty]
+ public partial bool IsBusy { get; set; }
+
+ [ObservableProperty]
+ public partial bool HasError { get; set; }
+
+ [ObservableProperty]
+ public partial string? Format { get; set; }
+
+ [ObservableProperty]
+ public partial bool HasResult { get; set; }
+
+ [RelayCommand]
+ public void SetFile(string path)
+ {
+ SelectedFile = path;
+ Status = Path.GetFileName(path);
+ Markdown = "";
+ HasError = false;
+ HasResult = false;
+ Format = null;
+ }
+
+ [RelayCommand]
+ public async Task ConvertAsync()
+ {
+ if (string.IsNullOrWhiteSpace(SelectedFile))
+ {
+ return;
+ }
+
+ IsBusy = true;
+ HasError = false;
+ HasResult = false;
+ Markdown = "";
+ Status = "Converting…";
+
+ try
+ {
+ byte[] bytes = await File.ReadAllBytesAsync(SelectedFile);
+
+ Format? format = _converter.DetectFormatByExtension(Path.GetExtension(SelectedFile))
+ ?? _converter.DetectFormat(bytes);
+
+ string markdown = format is null
+ ? await _converter.ToMarkdownBytesAsync(bytes)
+ : await _converter.ToMarkdownBytesAsync(bytes, format.Value);
+
+ Format = format?.ToString();
+ Markdown = markdown;
+ HasResult = true;
+ Status = $"Converted {bytes.Length:N0} bytes to Markdown.";
+ }
+ catch (AnydocException ex)
+ {
+ HasError = true;
+ Status = $"{ex.Code}: {ex.Message}";
+ }
+ catch (Exception ex)
+ {
+ HasError = true;
+ Status = ex.Message;
+ }
+ finally
+ {
+ IsBusy = false;
+ }
+ }
+}
diff --git a/dotnet/examples/AnydocAvaloniaDemo/ViewModels/ViewModelBase.cs b/dotnet/examples/AnydocAvaloniaDemo/ViewModels/ViewModelBase.cs
new file mode 100644
index 00000000..326f2107
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/ViewModels/ViewModelBase.cs
@@ -0,0 +1,7 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace AnydocAvaloniaDemo.ViewModels;
+
+public abstract class ViewModelBase : ObservableObject
+{
+}
diff --git a/dotnet/examples/AnydocAvaloniaDemo/Views/MainWindow.axaml b/dotnet/examples/AnydocAvaloniaDemo/Views/MainWindow.axaml
new file mode 100644
index 00000000..fcb5c836
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/Views/MainWindow.axaml
@@ -0,0 +1,59 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/dotnet/examples/AnydocAvaloniaDemo/Views/MainWindow.axaml.cs b/dotnet/examples/AnydocAvaloniaDemo/Views/MainWindow.axaml.cs
new file mode 100644
index 00000000..31bd2ab3
--- /dev/null
+++ b/dotnet/examples/AnydocAvaloniaDemo/Views/MainWindow.axaml.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Platform.Storage;
+using AnydocAvaloniaDemo.ViewModels;
+
+namespace AnydocAvaloniaDemo.Views;
+
+public partial class MainWindow : Window
+{
+ public MainWindow()
+ {
+ InitializeComponent();
+ }
+
+ protected override async void OnOpened(EventArgs e)
+ {
+ base.OnOpened(e);
+
+ if (DataContext is MainViewModel vm)
+ {
+ var button = this.FindControl