presubmit 0.1.0

package/vendor/lancedb/dist/oauth.d.ts

@@ -0,0 +1,66 @@
+/**
+ * OAuth authentication flow types.
+ */
+export declare enum OAuthFlowType {
+    /** Client Credentials grant (service-to-service / M2M). */
+    ClientCredentials = "client_credentials",
+    /** Azure Managed Identity via IMDS. */
+    AzureManagedIdentity = "azure_managed_identity"
+}
+/**
+ * OAuth configuration for LanceDB authentication.
+ *
+ * This is the public TypeScript OAuth configuration type. The generated
+ * `NativeOAuthConfig` type has the same runtime shape but is an implementation
+ * detail of the napi-rs binding.
+ *
+ * All token acquisition and refresh is handled in the Rust layer.
+ * This config is passed through to Rust via napi-rs.
+ *
+ * @example Client Credentials (service-to-service):
+ * ```typescript
+ * const config: OAuthConfig = {
+ *   issuerUrl: "https://login.microsoftonline.com/{tenant}/v2.0",
+ *   clientId: "app-id",
+ *   clientSecret: "secret",
+ *   scopes: ["api://lancedb-api/.default"],
+ * };
+ * ```
+ *
+ * @example Azure Managed Identity:
+ * ```typescript
+ * const config: OAuthConfig = {
+ *   issuerUrl: "https://login.microsoftonline.com/{tenant}/v2.0",
+ *   clientId: "app-id",
+ *   scopes: ["api://lancedb-api/.default"],
+ *   flow: OAuthFlowType.AzureManagedIdentity,
+ * };
+ * ```
+ */
+export interface OAuthConfig {
+    /**
+     * OIDC issuer URL or OAuth authority URL.
+     * For Azure: `https://login.microsoftonline.com/{tenant_id}/v2.0`
+     */
+    issuerUrl: string;
+    /** Application / Client ID. */
+    clientId: string;
+    /**
+     * OAuth scopes to request.
+     * For Azure managed identity, exactly one scope or resource is required.
+     * For example: `["api://{app_id}/.default"]`
+     */
+    scopes: string[];
+    /** Authentication flow (default: ClientCredentials). */
+    flow?: OAuthFlowType;
+    /** Client secret (required for ClientCredentials). */
+    clientSecret?: string;
+    /** Client ID for user-assigned managed identity (AzureManagedIdentity). */
+    managedIdentityClientId?: string;
+    /**
+     * Seconds before expiry to trigger proactive refresh (default: 300).
+     * Keep this well below the token TTL; if it is greater than or equal to
+     * the TTL, each request refreshes the token.
+     */
+    refreshBufferSecs?: number;
+}

package/vendor/lancedb/dist/oauth.js

@@ -0,0 +1,15 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuthFlowType = void 0;
+/**
+ * OAuth authentication flow types.
+ */
+var OAuthFlowType;
+(function (OAuthFlowType) {
+    /** Client Credentials grant (service-to-service / M2M). */
+    OAuthFlowType["ClientCredentials"] = "client_credentials";
+    /** Azure Managed Identity via IMDS. */
+    OAuthFlowType["AzureManagedIdentity"] = "azure_managed_identity";
+})(OAuthFlowType || (exports.OAuthFlowType = OAuthFlowType = {}));

package/vendor/lancedb/dist/otel.d.ts

@@ -0,0 +1,26 @@
+import { type MeterProvider } from "@opentelemetry/api";
+/**
+ * Register LanceDB metrics as OpenTelemetry observable instruments.
+ *
+ * Installs a process-global metrics recorder and creates one observable
+ * instrument per LanceDB metric (currently object store request counts, bytes,
+ * latency, errors, and throttles) on the given (or global) `MeterProvider`. The
+ * configured `MetricReader` then collects them on its own schedule.
+ *
+ * Counters and gauges map directly to observable counters/gauges. Because
+ * OpenTelemetry has no asynchronous histogram instrument, each histogram is
+ * exported Prometheus-style as cumulative `le` bucket counts (`<name>_bucket`,
+ * with an `le` attribute) plus `<name>_count` and `<name>_sum`.
+ *
+ * Requires `@opentelemetry/api` (a dependency) and, to actually export, an
+ * OpenTelemetry SDK such as `@opentelemetry/sdk-metrics`.
+ *
+ * @param meterProvider The provider to register instruments on. Defaults to the
+ *   global provider from `@opentelemetry/api`.
+ * @returns `true` if the recorder is installed and instruments are registered.
+ *   `false` if a different `metrics` recorder is already installed in this
+ *   process (only one global recorder is permitted), in which case a warning is
+ *   emitted and no instruments are created. Calling this more than once is safe;
+ *   instruments are created only on the first successful call.
+ */
+export declare function instrumentLanceDbMetrics(meterProvider?: MeterProvider): boolean;

package/vendor/lancedb/dist/otel.js

@@ -0,0 +1,114 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentLanceDbMetrics = instrumentLanceDbMetrics;
+const api_1 = require("@opentelemetry/api");
+const native_1 = require("./native");
+let instrumented = false;
+/**
+ * Register LanceDB metrics as OpenTelemetry observable instruments.
+ *
+ * Installs a process-global metrics recorder and creates one observable
+ * instrument per LanceDB metric (currently object store request counts, bytes,
+ * latency, errors, and throttles) on the given (or global) `MeterProvider`. The
+ * configured `MetricReader` then collects them on its own schedule.
+ *
+ * Counters and gauges map directly to observable counters/gauges. Because
+ * OpenTelemetry has no asynchronous histogram instrument, each histogram is
+ * exported Prometheus-style as cumulative `le` bucket counts (`<name>_bucket`,
+ * with an `le` attribute) plus `<name>_count` and `<name>_sum`.
+ *
+ * Requires `@opentelemetry/api` (a dependency) and, to actually export, an
+ * OpenTelemetry SDK such as `@opentelemetry/sdk-metrics`.
+ *
+ * @param meterProvider The provider to register instruments on. Defaults to the
+ *   global provider from `@opentelemetry/api`.
+ * @returns `true` if the recorder is installed and instruments are registered.
+ *   `false` if a different `metrics` recorder is already installed in this
+ *   process (only one global recorder is permitted), in which case a warning is
+ *   emitted and no instruments are created. Calling this more than once is safe;
+ *   instruments are created only on the first successful call.
+ */
+function instrumentLanceDbMetrics(meterProvider) {
+    if (!(0, native_1.registerLancedbMetricsRecorder)()) {
+        console.warn("Could not install the LanceDB metrics recorder: another `metrics` " +
+            "recorder is already installed in this process. LanceDB metrics will " +
+            "not be exported via OpenTelemetry.");
+        return false;
+    }
+    if (instrumented) {
+        return true;
+    }
+    const provider = meterProvider ?? api_1.metrics.getMeterProvider();
+    const meter = provider.getMeter("lancedb");
+    const scalarCallback = (metricName) => (result) => {
+        for (const point of (0, native_1.snapshotLancedbMetrics)()) {
+            if (point.name === metricName && point.value != null) {
+                result.observe(point.value, point.attributes);
+            }
+        }
+    };
+    const bucketCallback = (metricName) => (result) => {
+        for (const point of (0, native_1.snapshotLancedbMetrics)()) {
+            if (point.name !== metricName || point.buckets == null) {
+                continue;
+            }
+            for (const bucket of point.buckets) {
+                const attributes = {
+                    ...point.attributes,
+                    le: bucket.le,
+                };
+                result.observe(bucket.cumulativeCount, attributes);
+            }
+        }
+    };
+    const fieldCallback = (metricName, field) => (result) => {
+        for (const point of (0, native_1.snapshotLancedbMetrics)()) {
+            if (point.name !== metricName) {
+                continue;
+            }
+            const value = point[field];
+            if (value != null) {
+                result.observe(value, point.attributes);
+            }
+        }
+    };
+    for (const desc of (0, native_1.lancedbMetricsCatalog)()) {
+        const unit = desc.unit ?? "";
+        if (desc.kind === "counter") {
+            const counter = meter.createObservableCounter(desc.name, {
+                unit,
+                description: desc.description,
+            });
+            counter.addCallback(scalarCallback(desc.name));
+        }
+        else if (desc.kind === "gauge") {
+            const gauge = meter.createObservableGauge(desc.name, {
+                unit,
+                description: desc.description,
+            });
+            gauge.addCallback(scalarCallback(desc.name));
+        }
+        else if (desc.kind === "histogram") {
+            // `_bucket` and `_count` observe cumulative sample counts, not the
+            // histogram's measured quantity, so they are unitless; only `_sum`
+            // carries the histogram's unit.
+            const bucket = meter.createObservableCounter(`${desc.name}_bucket`, {
+                description: `${desc.description} (cumulative buckets)`,
+            });
+            bucket.addCallback(bucketCallback(desc.name));
+            const count = meter.createObservableCounter(`${desc.name}_count`, {
+                description: `${desc.description} (count)`,
+            });
+            count.addCallback(fieldCallback(desc.name, "count"));
+            const sum = meter.createObservableCounter(`${desc.name}_sum`, {
+                unit,
+                description: `${desc.description} (sum)`,
+            });
+            sum.addCallback(fieldCallback(desc.name, "sum"));
+        }
+    }
+    instrumented = true;
+    return true;
+}

package/vendor/lancedb/dist/permutation.d.ts

@@ -0,0 +1,143 @@
+import { Connection } from "./connection.js";
+import { PermutationBuilder as NativePermutationBuilder, ShuffleOptions, SplitCalculatedOptions, SplitHashOptions, SplitRandomOptions, SplitSequentialOptions } from "./native.js";
+import { Table } from "./table";
+/**
+ * A PermutationBuilder for creating data permutations with splits, shuffling, and filtering.
+ *
+ * This class provides a TypeScript wrapper around the native Rust PermutationBuilder,
+ * offering methods to configure data splits, shuffling, and filtering before executing
+ * the permutation to create a new table.
+ */
+export declare class PermutationBuilder {
+    private inner;
+    /**
+     * @hidden
+     */
+    constructor(inner: NativePermutationBuilder);
+    /**
+     * Configure the permutation to be persisted.
+     *
+     * @param connection - The connection to persist the permutation to
+     * @param tableName - The name of the table to create
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.persist(connection, "permutation_table");
+     * ```
+     */
+    persist(connection: Connection, tableName: string): PermutationBuilder;
+    /**
+     * Configure random splits for the permutation.
+     *
+     * @param options - Configuration for random splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Split by ratios
+     * builder.splitRandom({ ratios: [0.7, 0.3], seed: 42 });
+     *
+     * // Split by counts
+     * builder.splitRandom({ counts: [1000, 500], seed: 42 });
+     *
+     * // Split with fixed size
+     * builder.splitRandom({ fixed: 100, seed: 42 });
+     * ```
+     */
+    splitRandom(options: SplitRandomOptions): PermutationBuilder;
+    /**
+     * Configure hash-based splits for the permutation.
+     *
+     * @param options - Configuration for hash-based splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.splitHash({
+     *   columns: ["user_id"],
+     *   splitWeights: [70, 30],
+     *   discardWeight: 0
+     * });
+     * ```
+     */
+    splitHash(options: SplitHashOptions): PermutationBuilder;
+    /**
+     * Configure sequential splits for the permutation.
+     *
+     * @param options - Configuration for sequential splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Split by ratios
+     * builder.splitSequential({ ratios: [0.8, 0.2] });
+     *
+     * // Split by counts
+     * builder.splitSequential({ counts: [800, 200] });
+     *
+     * // Split with fixed size
+     * builder.splitSequential({ fixed: 1000 });
+     * ```
+     */
+    splitSequential(options: SplitSequentialOptions): PermutationBuilder;
+    /**
+     * Configure calculated splits for the permutation.
+     *
+     * @param options - Configuration for calculated splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.splitCalculated({ calculation: "user_id % 3" });
+     * ```
+     */
+    splitCalculated(options: SplitCalculatedOptions): PermutationBuilder;
+    /**
+     * Configure shuffling for the permutation.
+     *
+     * @param options - Configuration for shuffling
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Basic shuffle
+     * builder.shuffle({ seed: 42 });
+     *
+     * // Shuffle with clump size
+     * builder.shuffle({ seed: 42, clumpSize: 10 });
+     * ```
+     */
+    shuffle(options: ShuffleOptions): PermutationBuilder;
+    /**
+     * Configure filtering for the permutation.
+     *
+     * @param filter - SQL filter expression
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.filter("age > 18 AND status = 'active'");
+     * ```
+     */
+    filter(filter: string): PermutationBuilder;
+    /**
+     * Execute the permutation and create the destination table.
+     *
+     * @returns A Promise that resolves to the new Table instance
+     * @example
+     * ```ts
+     * const permutationTable = await builder.execute();
+     * console.log(`Created table: ${permutationTable.name}`);
+     * ```
+     */
+    execute(): Promise<Table>;
+}
+/**
+ * Create a permutation builder for the given table.
+ *
+ * @param table - The source table to create a permutation from
+ * @returns A PermutationBuilder instance
+ * @example
+ * ```ts
+ * const builder = permutationBuilder(sourceTable, "training_data")
+ *   .splitRandom({ ratios: [0.8, 0.2], seed: 42 })
+ *   .shuffle({ seed: 123 });
+ *
+ * const trainingTable = await builder.execute();
+ * ```
+ */
+export declare function permutationBuilder(table: Table): PermutationBuilder;

package/vendor/lancedb/dist/permutation.js

@@ -0,0 +1,184 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermutationBuilder = void 0;
+exports.permutationBuilder = permutationBuilder;
+const native_js_1 = require("./native.js");
+const table_1 = require("./table");
+/**
+ * A PermutationBuilder for creating data permutations with splits, shuffling, and filtering.
+ *
+ * This class provides a TypeScript wrapper around the native Rust PermutationBuilder,
+ * offering methods to configure data splits, shuffling, and filtering before executing
+ * the permutation to create a new table.
+ */
+class PermutationBuilder {
+    inner;
+    /**
+     * @hidden
+     */
+    constructor(inner) {
+        this.inner = inner;
+    }
+    /**
+     * Configure the permutation to be persisted.
+     *
+     * @param connection - The connection to persist the permutation to
+     * @param tableName - The name of the table to create
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.persist(connection, "permutation_table");
+     * ```
+     */
+    persist(connection, tableName) {
+        const localConnection = connection;
+        const newInner = this.inner.persist(localConnection.inner, tableName);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure random splits for the permutation.
+     *
+     * @param options - Configuration for random splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Split by ratios
+     * builder.splitRandom({ ratios: [0.7, 0.3], seed: 42 });
+     *
+     * // Split by counts
+     * builder.splitRandom({ counts: [1000, 500], seed: 42 });
+     *
+     * // Split with fixed size
+     * builder.splitRandom({ fixed: 100, seed: 42 });
+     * ```
+     */
+    splitRandom(options) {
+        const newInner = this.inner.splitRandom(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure hash-based splits for the permutation.
+     *
+     * @param options - Configuration for hash-based splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.splitHash({
+     *   columns: ["user_id"],
+     *   splitWeights: [70, 30],
+     *   discardWeight: 0
+     * });
+     * ```
+     */
+    splitHash(options) {
+        const newInner = this.inner.splitHash(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure sequential splits for the permutation.
+     *
+     * @param options - Configuration for sequential splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Split by ratios
+     * builder.splitSequential({ ratios: [0.8, 0.2] });
+     *
+     * // Split by counts
+     * builder.splitSequential({ counts: [800, 200] });
+     *
+     * // Split with fixed size
+     * builder.splitSequential({ fixed: 1000 });
+     * ```
+     */
+    splitSequential(options) {
+        const newInner = this.inner.splitSequential(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure calculated splits for the permutation.
+     *
+     * @param options - Configuration for calculated splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.splitCalculated({ calculation: "user_id % 3" });
+     * ```
+     */
+    splitCalculated(options) {
+        const newInner = this.inner.splitCalculated(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure shuffling for the permutation.
+     *
+     * @param options - Configuration for shuffling
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Basic shuffle
+     * builder.shuffle({ seed: 42 });
+     *
+     * // Shuffle with clump size
+     * builder.shuffle({ seed: 42, clumpSize: 10 });
+     * ```
+     */
+    shuffle(options) {
+        const newInner = this.inner.shuffle(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure filtering for the permutation.
+     *
+     * @param filter - SQL filter expression
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.filter("age > 18 AND status = 'active'");
+     * ```
+     */
+    filter(filter) {
+        const newInner = this.inner.filter(filter);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Execute the permutation and create the destination table.
+     *
+     * @returns A Promise that resolves to the new Table instance
+     * @example
+     * ```ts
+     * const permutationTable = await builder.execute();
+     * console.log(`Created table: ${permutationTable.name}`);
+     * ```
+     */
+    async execute() {
+        const nativeTable = await this.inner.execute();
+        return new table_1.LocalTable(nativeTable);
+    }
+}
+exports.PermutationBuilder = PermutationBuilder;
+/**
+ * Create a permutation builder for the given table.
+ *
+ * @param table - The source table to create a permutation from
+ * @returns A PermutationBuilder instance
+ * @example
+ * ```ts
+ * const builder = permutationBuilder(sourceTable, "training_data")
+ *   .splitRandom({ ratios: [0.8, 0.2], seed: 42 })
+ *   .shuffle({ seed: 123 });
+ *
+ * const trainingTable = await builder.execute();
+ * ```
+ */
+function permutationBuilder(table) {
+    // Extract the inner native table from the TypeScript wrapper
+    const localTable = table;
+    // Access inner through type assertion since it's private
+    const nativeBuilder = (0, native_js_1.permutationBuilder)(
+    // biome-ignore lint/suspicious/noExplicitAny: need access to private variable
+    localTable.inner);
+    return new PermutationBuilder(nativeBuilder);
+}