@xybrid/react-native 0.10.0-rc1

package/ios/xybrid_natives.rb

@@ -0,0 +1,178 @@
+# Resolves the two iOS pieces the npm tarball does not carry by default, at
+# `pod install` time (the podspec calls this while CocoaPods evaluates it):
+#
+#   ios/Frameworks/XybridFFI.xcframework  — the Rust core (~64 MB zipped).
+#     Downloaded from the GitHub Release for this package's version and
+#     checked against the SHA-256 in package.json, exactly like Package.swift's
+#     binaryTarget. Cached in ~/.xybrid/cache/xcframework, next to the SDK's
+#     other caches, so each version downloads once per machine.
+#   ios/XybridSwift/{Xybrid,xybrid_bolt}.swift — the Swift SDK sources. The
+#     published tarball includes them; in the xybrid monorepo they are synced
+#     from bindings/apple on every install.
+#
+# Where the XCFramework comes from, first match wins:
+#   1. XYBRID_XCFRAMEWORK_PATH — an XybridFFI.xcframework directory or .zip
+#   2. an ios/Frameworks/XybridFFI.xcframework you staged yourself
+#   3. in the monorepo: <repo>/bazel-bin/bindings/apple/XybridFFI.xcframework.zip
+#      (a release download could not match the working tree's C ABI, so the
+#      monorepo never falls back to one)
+#   4. otherwise: the pinned release asset (XYBRID_NATIVES_BASE_URL = mirror)
+#
+# Plain Ruby + curl/unzip/shasum from macOS: this runs inside `pod install`,
+# so it must not need anything a stock Mac lacks.
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'tmpdir'
+
+module XybridNatives
+  FRAMEWORK = 'XybridFFI.xcframework'.freeze
+  STAMP = '.xybrid-natives'.freeze
+  SWIFT_SOURCES = %w[Xybrid.swift xybrid_bolt.swift].freeze
+  DEFAULT_BASE_URL = 'https://github.com/xybrid-ai/xybrid/releases/download'.freeze
+
+  module_function
+
+  # Make sure every native input exists; returns the framework path relative
+  # to the pod root, for `vendored_frameworks`.
+  def prepare!(root)
+    # Resolve symlinks: `file:` installs link node_modules to the source tree.
+    root = File.realpath(root)
+    package = JSON.parse(File.read(File.join(root, 'package.json')))
+    monorepo = File.expand_path('../..', root) if File.file?(File.join(root, '../apple/Sources/Xybrid/Xybrid.swift'))
+    ensure_swift_sources!(root, monorepo)
+    ensure_xcframework!(root, package, monorepo)
+    "ios/Frameworks/#{FRAMEWORK}"
+  end
+
+  def log(message)
+    if defined?(Pod::UI)
+      Pod::UI.puts("[@xybrid/react-native] #{message}")
+    else
+      puts("[@xybrid/react-native] #{message}")
+    end
+  end
+
+  def fail!(message)
+    raise(defined?(Pod::Informative) ? Pod::Informative : RuntimeError, "[@xybrid/react-native] #{message}")
+  end
+
+  def ensure_swift_sources!(root, monorepo)
+    staged = File.join(root, 'ios', 'XybridSwift')
+    if monorepo
+      # Always sync, so a stale copy can never drift from bindings/apple.
+      source = File.join(monorepo, 'bindings', 'apple', 'Sources', 'Xybrid')
+      FileUtils.mkdir_p(staged)
+      SWIFT_SOURCES.each do |name|
+        from = File.join(source, name)
+        to = File.join(staged, name)
+        FileUtils.cp(from, to) unless File.file?(to) && FileUtils.identical?(from, to)
+      end
+      return
+    end
+    return if SWIFT_SOURCES.all? { |name| File.file?(File.join(staged, name)) }
+
+    fail!('ios/XybridSwift is missing the Swift SDK sources; reinstall @xybrid/react-native from npm.')
+  end
+
+  def ensure_xcframework!(root, package, monorepo)
+    frameworks = File.join(root, 'ios', 'Frameworks')
+    target = File.join(frameworks, FRAMEWORK)
+    stamp = File.join(frameworks, STAMP)
+    installed = File.file?(stamp) ? File.read(stamp).strip : nil
+    version = package.fetch('version')
+
+    local = ENV['XYBRID_XCFRAMEWORK_PATH'].to_s.strip
+    local = File.expand_path(local) unless local.empty?
+    # A framework staged by hand (no stamp) is used as-is.
+    return if local.empty? && File.directory?(target) && installed.nil?
+
+    if local.empty? && monorepo
+      local = File.join(monorepo, 'bazel-bin', 'bindings', 'apple', 'XybridFFI.xcframework.zip')
+      unless File.exist?(local)
+        fail!('build the XCFramework first: `bazel build --config=ios //bindings/apple:XybridFFI` ' \
+              '(or set XYBRID_XCFRAMEWORK_PATH).')
+      end
+    end
+
+    unless local.empty?
+      fail!("XYBRID_XCFRAMEWORK_PATH does not exist: #{local}") unless File.exist?(local)
+      source = "local:#{local}:#{fingerprint(local)}"
+      return if File.directory?(target) && installed == source
+
+      replace!(frameworks, target) do
+        File.directory?(local) ? FileUtils.cp_r(local, target) : unzip!(local, frameworks)
+      end
+      File.write(stamp, "#{source}\n")
+      log("Using the XCFramework from #{local}")
+      return
+    end
+
+    sha256 = package.dig('xybrid', 'iosXcframeworkSha256').to_s.strip
+    fail!("no XCFramework checksum is pinned for #{version}; set XYBRID_XCFRAMEWORK_PATH.") if sha256.empty?
+    source = "release:#{version}:#{sha256}"
+    return if File.directory?(target) && installed == source
+
+    zip = cached_download!(version, sha256)
+    replace!(frameworks, target) { unzip!(zip, frameworks) }
+    File.write(stamp, "#{source}\n")
+  end
+
+  def replace!(frameworks, target)
+    FileUtils.rm_rf(target)
+    FileUtils.rm_f(File.join(frameworks, STAMP))
+    FileUtils.mkdir_p(frameworks)
+    yield
+  end
+
+  # Identifies a local XCFramework (directory or .zip) by every file's path,
+  # size and mtime to the nanosecond. A directory's own mtime only moves when
+  # its direct entries change, so rebuilding a library inside the framework
+  # would otherwise keep serving the stale copy.
+  def fingerprint(path)
+    files = File.directory?(path) ? Dir.glob(File.join(path, '**', '*'), File::FNM_DOTMATCH) : [path]
+    digest = Digest::SHA256.new
+    files.select { |file| File.file?(file) }.sort.each do |file|
+      stat = File.stat(file)
+      digest << "#{file.delete_prefix(path)}\0#{stat.size}\0#{stat.mtime.to_i}.#{stat.mtime.nsec}\n"
+    end
+    digest.hexdigest
+  end
+
+  def cached_download!(version, sha256)
+    cache = File.join(Dir.home, '.xybrid', 'cache', 'xcframework')
+    name = "XybridFFI-v#{version}.xcframework.zip"
+    zip = File.join(cache, name)
+    return zip if File.file?(zip) && Digest::SHA256.file(zip).hexdigest == sha256
+
+    base = ENV['XYBRID_NATIVES_BASE_URL'].to_s.strip
+    base = DEFAULT_BASE_URL if base.empty?
+    url = "#{base.chomp('/')}/v#{version}/#{name}"
+    FileUtils.mkdir_p(cache)
+    partial = "#{zip}.partial"
+    log("Downloading #{url}")
+    unless system('curl', '--fail', '--location', '--silent', '--show-error',
+                  '--retry', '3', '--output', partial, url)
+      FileUtils.rm_f(partial)
+      fail!("could not download #{url}. Set XYBRID_NATIVES_BASE_URL to a mirror, or " \
+            'XYBRID_XCFRAMEWORK_PATH to a local copy.')
+    end
+    actual = Digest::SHA256.file(partial).hexdigest
+    unless actual == sha256
+      FileUtils.rm_f(partial)
+      fail!("checksum mismatch for #{name}: expected #{sha256}, got #{actual}")
+    end
+    FileUtils.mv(partial, zip)
+    zip
+  end
+
+  def unzip!(zip, destination)
+    Dir.mktmpdir('xybrid-xcframework') do |scratch|
+      fail!("could not unzip #{zip}") unless system('unzip', '-q', '-o', zip, '-d', scratch)
+      extracted = Dir.glob(File.join(scratch, '**', FRAMEWORK)).min_by(&:length)
+      fail!("#{zip} does not contain #{FRAMEWORK}") unless extracted
+      FileUtils.mv(extracted, File.join(destination, FRAMEWORK))
+    end
+  end
+end

package/lib/commonjs/NativeXybrid.js

@@ -0,0 +1,24 @@
+"use strict";
+// TurboModule spec consumed by React Native Codegen — the one contract both
+// native shims are compiled against: Android extends the generated
+// `NativeXybridSpec` class and iOS conforms to the generated
+// `NativeXybridSpec` protocol (tests/spec-conformance.test.mjs checks the
+// selectors without a Mac).
+//
+// Codegen accepts only `string`, `number`, `boolean`, `Object`, arrays and
+// `Promise`s of those, and `| null`. Structured values therefore cross as
+// plain `Object`s: the TS facade (src/index.ts) builds and narrows them, and
+// the native codecs (ios/XybridCodec.swift, android/.../XybridCodec.kt)
+// translate them to and from the bolt types.
+//
+// Native objects (models, conversation contexts, cancellation tokens, token
+// streams, downloads, pipelines, live-ASR sessions) are opaque string handles
+// held in one registry per platform. `dispose` frees any of them, and freeing
+// a model also disposes the token streams started from it.
+//
+// Nothing here is public API. Keep method names distinct from NSObject /
+// Java `Object` members (hence `dispose`, not `release`; `sdkVersion`, not
+// `version`).
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.TurboModuleRegistry.getEnforcing('RNXybrid');

package/lib/commonjs/base64.js

@@ -0,0 +1,45 @@
+"use strict";
+// Minimal base64 for the one binary payload JS produces itself: live-ASR PCM.
+// Hermes has no Buffer, and `btoa` only takes binary strings, so encode the
+// bytes directly. Every platform React Native runs on is little-endian, which
+// is the byte order the native shims decode Float32 samples in.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesToBase64 = bytesToBase64;
+exports.float32ToBase64 = float32ToBase64;
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+/** Standard (RFC 4648, padded) base64 of `bytes`. */
+function bytesToBase64(bytes) {
+    const chunks = [];
+    let chunk = '';
+    let i = 0;
+    for (; i + 2 < bytes.length; i += 3) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        chunk +=
+            ALPHABET[(n >> 18) & 63] +
+                ALPHABET[(n >> 12) & 63] +
+                ALPHABET[(n >> 6) & 63] +
+                ALPHABET[n & 63];
+        // Flush periodically so long inputs don't build one enormous rope.
+        if (chunk.length >= 8192) {
+            chunks.push(chunk);
+            chunk = '';
+        }
+    }
+    const rest = bytes.length - i;
+    if (rest === 1) {
+        const n = bytes[i] << 16;
+        chunk += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63] + '==';
+    }
+    else if (rest === 2) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8);
+        chunk +=
+            ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63] + ALPHABET[(n >> 6) & 63] + '=';
+    }
+    chunks.push(chunk);
+    return chunks.join('');
+}
+/** Base64 of Float32 PCM samples as little-endian bytes. */
+function float32ToBase64(samples) {
+    const floats = samples instanceof Float32Array ? samples : Float32Array.from(samples);
+    return bytesToBase64(new Uint8Array(floats.buffer, floats.byteOffset, floats.byteLength));
+}

package/lib/commonjs/cancel.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindCancel = bindCancel;
+const NativeXybrid_1 = __importDefault(require("./NativeXybrid"));
+const NO_SIGNAL = { token: null, release: () => Promise.resolve() };
+/**
+ * Create a native stop button wired to `signal`. Aborting the signal cancels
+ * the token, which stops generation at the next token boundary. A signal
+ * that is already aborted cancels the token before the call starts, so the
+ * call rejects with `xybrid_cancelled` instead of running.
+ */
+async function bindCancel(signal) {
+    if (!signal)
+        return NO_SIGNAL;
+    const token = await NativeXybrid_1.default.createCancelToken();
+    const onAbort = () => {
+        NativeXybrid_1.default.cancel(token).catch(() => { });
+    };
+    if (signal.aborted) {
+        await NativeXybrid_1.default.cancel(token);
+    }
+    else {
+        signal.addEventListener('abort', onAbort);
+    }
+    return {
+        token,
+        release: async () => {
+            signal.removeEventListener('abort', onAbort);
+            await NativeXybrid_1.default.dispose(token).catch(() => { });
+        },
+    };
+}

package/lib/commonjs/context.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationContext = void 0;
+const NativeXybrid_1 = __importDefault(require("./NativeXybrid"));
+const wire_1 = require("./wire");
+/**
+ * Multi-turn conversation history, held natively. Pass it to
+ * `model.run(envelope, { context })` or `runStreaming`; inference reads the
+ * history but never changes it. The prompt you run is appended to the
+ * history for that run only, so push both turns *after* the run — pushing the
+ * prompt first would send it twice:
+ *
+ * ```ts
+ * const chat = await ConversationContext.create();
+ * await chat.setSystem('You are terse.');
+ *
+ * const question = Envelope.user('What is the capital of France?');
+ * const reply = await model.run(question, { context: chat });
+ * await chat.push(question);
+ * await chat.push(reply.envelope); // already tagged `assistant`
+ * ```
+ */
+class ConversationContext {
+    constructor(
+    /** Opaque native handle. */
+    handle) {
+        this.handle = handle;
+    }
+    /** A new, empty conversation; `id` defaults to a fresh one (telemetry correlation). */
+    static async create(id) {
+        return new ConversationContext(await NativeXybrid_1.default.createContext(id ?? null));
+    }
+    /** Append a turn. Give it a `role` (see `Envelope.user` / `Envelope.assistant`). */
+    push(envelope) {
+        return NativeXybrid_1.default.contextPush(this.handle, (0, wire_1.toWireEnvelope)(envelope));
+    }
+    /** Set the persistent system prompt; it survives {@link clear}. */
+    setSystem(system) {
+        const envelope = typeof system === 'string' ? { kind: 'text', text: system, role: 'system' } : system;
+        return NativeXybrid_1.default.contextSetSystem(this.handle, (0, wire_1.toWireEnvelope)(envelope));
+    }
+    /** Drop the history; the system prompt is kept. */
+    clear() {
+        return NativeXybrid_1.default.contextClear(this.handle);
+    }
+    /** Id, history length and whether a system prompt is set. */
+    async info() {
+        return (await NativeXybrid_1.default.contextInfo(this.handle));
+    }
+    /** History turns in order, excluding the system prompt. */
+    async history() {
+        const wire = (await NativeXybrid_1.default.contextHistory(this.handle));
+        return wire.map(wire_1.fromWireEnvelope);
+    }
+    /** Cap the history; older turns are pruned first, immediately. */
+    setMaxHistoryLength(length) {
+        return NativeXybrid_1.default.contextSetMaxHistoryLength(this.handle, length);
+    }
+    /** Free the native context. Runs already started keep their snapshot. */
+    release() {
+        return NativeXybrid_1.default.dispose(this.handle);
+    }
+}
+exports.ConversationContext = ConversationContext;

package/lib/commonjs/envelope.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Envelope = void 0;
+const NativeXybrid_1 = __importDefault(require("./NativeXybrid"));
+const wire_1 = require("./wire");
+/**
+ * Envelope factories, named like the Swift and Kotlin `Envelope` helpers.
+ * Object literals (`{ kind: 'text', text }`) work just as well; these only
+ * save typing and apply the same defaults.
+ */
+exports.Envelope = {
+    /** A text prompt, or text to speak with an optional TTS voice and speed. */
+    text(text, options = {}) {
+        return { kind: 'text', text, ...options };
+    },
+    /** A user turn for a conversation. */
+    user(text) {
+        return { kind: 'text', text, role: 'user' };
+    },
+    /** An assistant turn for a conversation (e.g. a model reply you keep). */
+    assistant(text) {
+        return { kind: 'text', text, role: 'assistant' };
+    },
+    /** A system prompt. */
+    system(text) {
+        return { kind: 'text', text, role: 'system' };
+    },
+    /** PCM/WAV audio, base64-encoded. Defaults to 16 kHz mono. */
+    audio(bytesBase64, options = {}) {
+        return {
+            kind: 'audio',
+            bytesBase64,
+            sampleRate: options.sampleRate ?? 16000,
+            channels: options.channels ?? 1,
+        };
+    },
+    /** An embedding vector. */
+    embedding(data) {
+        return { kind: 'embedding', data };
+    },
+    /**
+     * An encoded image for vision-language models. The bytes are validated
+     * natively at run time (`xybrid_invalid_image` on bad input).
+     */
+    image(bytesBase64, format) {
+        return { kind: 'image', bytesBase64, format: (0, wire_1.normalizeImageFormat)(format) };
+    },
+    /** A user message with image attachments, for vision-language models. */
+    userMessage(text, images = []) {
+        if (!images.every((image) => image?.kind === 'image')) {
+            throw new TypeError('Envelope.userMessage accepts only image envelopes');
+        }
+        return {
+            kind: 'multipart',
+            parts: [{ kind: 'text', text }, ...images],
+            role: 'user',
+        };
+    },
+    /**
+     * The continuation envelope for the turn after the model asked for tools.
+     *
+     * One `run` is one model turn, so the tool loop lives in your code: run a
+     * request carrying `generationConfig.tools`, execute every
+     * `result.toolCalls` entry, then run this envelope (with the same tools) to
+     * feed the outcomes back.
+     *
+     * @param userText the original user message of the turn being continued.
+     * @param priorAssistantText that turn's raw output — `result.text` from a
+     *   batch run, or the terminal token's `rawText` when streaming.
+     * @param results tool outcomes, in call order.
+     */
+    async toolResults(userText, priorAssistantText, results) {
+        const wire = (await NativeXybrid_1.default.toolResultsEnvelope(userText, priorAssistantText, results.map(wire_1.toWireToolResult)));
+        return (0, wire_1.fromWireEnvelope)(wire);
+    },
+};

package/lib/commonjs/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+// Every native rejection carries one of these codes as `error.code`. The
+// SDK codes map 1:1 onto bolt's `XybridError` variants (same order as
+// crates/xybrid-bolt/src/lib.rs); the last three are raised by the React
+// Native layer itself.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XybridErrorCodes = void 0;
+exports.isXybridError = isXybridError;
+exports.isRetryable = isRetryable;
+/** Stable error codes for `XybridError.code`. */
+exports.XybridErrorCodes = [
+    'xybrid_model_not_found',
+    'xybrid_directory_not_found',
+    'xybrid_metadata_not_found',
+    'xybrid_metadata_invalid',
+    'xybrid_load_error',
+    'xybrid_inference_error',
+    'xybrid_aborted_cloud_fallback',
+    'xybrid_streaming_unsupported',
+    'xybrid_not_loaded',
+    'xybrid_config_error',
+    'xybrid_network_error',
+    'xybrid_offline',
+    'xybrid_io_error',
+    'xybrid_cache_error',
+    'xybrid_pipeline_error',
+    'xybrid_circuit_open',
+    'xybrid_rate_limited',
+    'xybrid_timeout',
+    'xybrid_missing_artifact',
+    'xybrid_unsupported_model_capability',
+    'xybrid_unsupported_backend_capability',
+    'xybrid_invalid_image',
+    'xybrid_cancelled',
+    // React Native layer:
+    /** The handle was never issued, was released, or names another kind of object. */
+    'xybrid_handle',
+    /** A JS argument could not be decoded (bad envelope, options, source, base64…). */
+    'xybrid_invalid_argument',
+    /** Anything unexpected; the message carries the detail. */
+    'xybrid_unknown',
+];
+const CODES = new Set(exports.XybridErrorCodes);
+/** Narrow an unknown rejection to a {@link XybridError}. */
+function isXybridError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const { code } = error;
+    return typeof code === 'string' && CODES.has(code);
+}
+// Mirrors `RetryableError::is_retryable` on the Rust `SdkError`.
+const RETRYABLE = new Set([
+    'xybrid_network_error',
+    'xybrid_rate_limited',
+    'xybrid_timeout',
+    'xybrid_offline',
+]);
+/** Whether retrying the same call later can succeed (network, rate limit, timeout, offline). */
+function isRetryable(error) {
+    return isXybridError(error) && RETRYABLE.has(error.code);
+}

package/lib/commonjs/index.js

@@ -0,0 +1,59 @@
+"use strict";
+// @xybrid/react-native — on-device (and optionally cloud) inference for React
+// Native, backed by the same Rust SDK as the Swift, Kotlin, Flutter and Unity
+// bindings.
+//
+//   await Xybrid.initialize({ apiKey });            // optional
+//   const model = await ModelLoader.fromRegistry('qwen3.5-0.8b').load();
+//   const result = await model.run(Envelope.text('Hello'));
+//   await model.release();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.float32ToBase64 = exports.bytesToBase64 = exports.isXybridError = exports.isRetryable = exports.XybridErrorCodes = exports.greedy = exports.creative = exports.GenerationConfigs = exports.Envelope = exports.StreamingSession = exports.Pipeline = exports.ConversationContext = exports.ModelLoader = exports.ModelDownload = exports.Model = exports.Xybrid = void 0;
+exports.jsonSchemaToGbnf = jsonSchemaToGbnf;
+const NativeXybrid_1 = __importDefault(require("./NativeXybrid"));
+var xybrid_1 = require("./xybrid");
+Object.defineProperty(exports, "Xybrid", { enumerable: true, get: function () { return xybrid_1.Xybrid; } });
+var model_1 = require("./model");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return model_1.Model; } });
+Object.defineProperty(exports, "ModelDownload", { enumerable: true, get: function () { return model_1.ModelDownload; } });
+Object.defineProperty(exports, "ModelLoader", { enumerable: true, get: function () { return model_1.ModelLoader; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "ConversationContext", { enumerable: true, get: function () { return context_1.ConversationContext; } });
+var pipeline_1 = require("./pipeline");
+Object.defineProperty(exports, "Pipeline", { enumerable: true, get: function () { return pipeline_1.Pipeline; } });
+var session_1 = require("./session");
+Object.defineProperty(exports, "StreamingSession", { enumerable: true, get: function () { return session_1.StreamingSession; } });
+var envelope_1 = require("./envelope");
+Object.defineProperty(exports, "Envelope", { enumerable: true, get: function () { return envelope_1.Envelope; } });
+var presets_1 = require("./presets");
+Object.defineProperty(exports, "GenerationConfigs", { enumerable: true, get: function () { return presets_1.GenerationConfigs; } });
+Object.defineProperty(exports, "creative", { enumerable: true, get: function () { return presets_1.creative; } });
+Object.defineProperty(exports, "greedy", { enumerable: true, get: function () { return presets_1.greedy; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "XybridErrorCodes", { enumerable: true, get: function () { return errors_1.XybridErrorCodes; } });
+Object.defineProperty(exports, "isRetryable", { enumerable: true, get: function () { return errors_1.isRetryable; } });
+Object.defineProperty(exports, "isXybridError", { enumerable: true, get: function () { return errors_1.isXybridError; } });
+var base64_1 = require("./base64");
+Object.defineProperty(exports, "bytesToBase64", { enumerable: true, get: function () { return base64_1.bytesToBase64; } });
+Object.defineProperty(exports, "float32ToBase64", { enumerable: true, get: function () { return base64_1.float32ToBase64; } });
+/**
+ * Convert a JSON Schema (object or JSON string) into a GBNF grammar for
+ * `generationConfig.grammar`, so a local LLM emits schema-valid JSON. Runs the
+ * same native converter every binding uses; rejects with
+ * `xybrid_config_error` on invalid JSON or an unsupported construct.
+ *
+ * ```ts
+ * const grammar = await jsonSchemaToGbnf({
+ *   type: 'object',
+ *   properties: { name: { type: 'string' } },
+ *   required: ['name'],
+ * });
+ * const result = await model.run(prompt, { generationConfig: { grammar } });
+ * ```
+ */
+function jsonSchemaToGbnf(schema) {
+    return NativeXybrid_1.default.jsonSchemaToGbnf(typeof schema === 'string' ? schema : JSON.stringify(schema));
+}