grepmax 0.26.52 → 0.26.53

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

@@ -0,0 +1,93 @@
+import { Table as ArrowTable } from "apache-arrow";
+import { JobFailureInfo, Job as NativeJob } from "./native";
+/** Which of a job's events {@link Job.events} returns. */
+export interface JobEventsOptions {
+    /** Maximum event rows to return, up to the server maximum of 10,000. */
+    limit?: number;
+    /** SQL-like filter over the event columns. */
+    filter?: string;
+}
+/**
+ * A handle to an operation that may still be running.
+ *
+ * The operation may already be complete when the handle is created.
+ *
+ * The detail getters read what the handle last observed. Submitting an
+ * operation returns only a job id, so populating them eagerly would cost an
+ * extra round trip on every call:
+ *
+ * - {@link Job.refresh} and {@link Job.status} fetch the whole record.
+ * - {@link Job.wait} records the terminal state it establishes, but not the
+ *   rest of the record.
+ * - Everything is null until one of those runs.
+ *
+ * @hideconstructor
+ */
+export declare class Job {
+    private readonly inner;
+    constructor(inner: NativeJob);
+    /**
+     * Identifies the operation on the server that is running it.
+     *
+     * Operations that run in this process have no server id. The value is
+     * opaque: parsing it or storing it to resume the job later is not supported.
+     */
+    get id(): string | null;
+    /** The last observed lifecycle state, without contacting the backend. */
+    get state(): string | null;
+    /**
+     * The job's type, as the server names it. Null for an in-process job, which
+     * has no server-side record.
+     */
+    get jobType(): string | null;
+    /** When the job was created, in milliseconds since the epoch. */
+    get creationMs(): number | null;
+    /** The job-type-specific specification it was submitted with. */
+    get spec(): any | null;
+    /**
+     * The job-type-specific terminal result. Null until the job succeeds, so a
+     * job that never terminates reports its progress through {@link Job.events}
+     * instead.
+     */
+    get result(): any | null;
+    /** Why the job failed, when it failed and the server reports a reason. */
+    get failure(): JobFailureInfo | null;
+    /**
+     * The operation's current lifecycle state: "running", "finished", "failed",
+     * or "cancelled".
+     *
+     * A point snapshot; unlike {@link Job.wait} it does not block or reject on a
+     * terminal failure state. Also refreshes the getters above.
+     */
+    status(): Promise<string>;
+    /** Wait until the operation reaches a terminal state. */
+    wait(): Promise<void>;
+    /** Request cancellation. Cancelling a finished operation is a no-op. */
+    cancel(): Promise<void>;
+    /**
+     * Ask the backend for this job's current state, and for a server-side job
+     * its full record, then cache it for the getters above.
+     */
+    refresh(): Promise<void>;
+    /**
+     * This job's recorded lifecycle events.
+     *
+     * Where the getters above report a terminal result only once the job reaches
+     * one, events are written as the job runs and outlive the workers that
+     * produced them. A distributed job records a `claim`/`claim_complete` pair
+     * per unit of work, each carrying `rows_processed`, so a job that never
+     * finishes still accounts for what it did.
+     *
+     * The server caps results at 1000 rows by default and 10,000 at most, and
+     * truncates without saying so, so pass `limit` for a job that emits an event
+     * per fragment. `filter` is a SQL-like expression over the `state`,
+     * `updated_by`, `emitted_from`, `emitted_by`, and `claim_entity` columns.
+     */
+    events(options?: JobEventsOptions): Promise<ArrowTable>;
+    /**
+     * Every field the handle currently knows, one per line, with the JSON
+     * payloads indented -- a refresh job's spec and result are the point of
+     * printing it.
+     */
+    toString(): string;
+}

package/dist/vendor/lancedb/job.js

@@ -0,0 +1,163 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = void 0;
+const apache_arrow_1 = require("apache-arrow");
+/**
+ * A handle to an operation that may still be running.
+ *
+ * The operation may already be complete when the handle is created.
+ *
+ * The detail getters read what the handle last observed. Submitting an
+ * operation returns only a job id, so populating them eagerly would cost an
+ * extra round trip on every call:
+ *
+ * - {@link Job.refresh} and {@link Job.status} fetch the whole record.
+ * - {@link Job.wait} records the terminal state it establishes, but not the
+ *   rest of the record.
+ * - Everything is null until one of those runs.
+ *
+ * @hideconstructor
+ */
+class Job {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    /**
+     * Identifies the operation on the server that is running it.
+     *
+     * Operations that run in this process have no server id. The value is
+     * opaque: parsing it or storing it to resume the job later is not supported.
+     */
+    get id() {
+        return this.inner.id ?? null;
+    }
+    /** The last observed lifecycle state, without contacting the backend. */
+    get state() {
+        return this.inner.state ?? null;
+    }
+    /**
+     * The job's type, as the server names it. Null for an in-process job, which
+     * has no server-side record.
+     */
+    get jobType() {
+        return this.inner.jobType ?? null;
+    }
+    /** When the job was created, in milliseconds since the epoch. */
+    get creationMs() {
+        return this.inner.creationMs ?? null;
+    }
+    /** The job-type-specific specification it was submitted with. */
+    // biome-ignore lint/suspicious/noExplicitAny: shape varies by job type
+    get spec() {
+        return parseJson(this.inner.specJson);
+    }
+    /**
+     * The job-type-specific terminal result. Null until the job succeeds, so a
+     * job that never terminates reports its progress through {@link Job.events}
+     * instead.
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: shape varies by job type
+    get result() {
+        return parseJson(this.inner.resultJson);
+    }
+    /** Why the job failed, when it failed and the server reports a reason. */
+    get failure() {
+        return this.inner.failure ?? null;
+    }
+    /**
+     * The operation's current lifecycle state: "running", "finished", "failed",
+     * or "cancelled".
+     *
+     * A point snapshot; unlike {@link Job.wait} it does not block or reject on a
+     * terminal failure state. Also refreshes the getters above.
+     */
+    async status() {
+        return this.inner.status();
+    }
+    /** Wait until the operation reaches a terminal state. */
+    async wait() {
+        return this.inner.wait();
+    }
+    /** Request cancellation. Cancelling a finished operation is a no-op. */
+    async cancel() {
+        return this.inner.cancel();
+    }
+    /**
+     * Ask the backend for this job's current state, and for a server-side job
+     * its full record, then cache it for the getters above.
+     */
+    async refresh() {
+        return this.inner.refresh();
+    }
+    /**
+     * This job's recorded lifecycle events.
+     *
+     * Where the getters above report a terminal result only once the job reaches
+     * one, events are written as the job runs and outlive the workers that
+     * produced them. A distributed job records a `claim`/`claim_complete` pair
+     * per unit of work, each carrying `rows_processed`, so a job that never
+     * finishes still accounts for what it did.
+     *
+     * The server caps results at 1000 rows by default and 10,000 at most, and
+     * truncates without saying so, so pass `limit` for a job that emits an event
+     * per fragment. `filter` is a SQL-like expression over the `state`,
+     * `updated_by`, `emitted_from`, `emitted_by`, and `claim_entity` columns.
+     */
+    async events(options) {
+        const buf = await this.inner.events(options?.limit, options?.filter);
+        if (buf.length === 0) {
+            return new apache_arrow_1.Table();
+        }
+        return (0, apache_arrow_1.tableFromIPC)(buf);
+    }
+    /**
+     * Every field the handle currently knows, one per line, with the JSON
+     * payloads indented -- a refresh job's spec and result are the point of
+     * printing it.
+     */
+    toString() {
+        if (this.state === null) {
+            const known = this.id === null ? "" : `id=${JSON.stringify(this.id)}, `;
+            return `Job(${known}not refreshed)`;
+        }
+        const fields = [];
+        if (this.id !== null) {
+            fields.push(`id=${JSON.stringify(this.id)}`);
+        }
+        fields.push(`state=${JSON.stringify(this.state)}`);
+        if (this.jobType !== null) {
+            fields.push(`jobType=${JSON.stringify(this.jobType)}`);
+        }
+        if (this.creationMs !== null) {
+            fields.push(`creationMs=${this.creationMs}`);
+        }
+        for (const [name, value] of [
+            ["spec", this.spec],
+            ["result", this.result],
+        ]) {
+            if (value !== null) {
+                fields.push(`${name}=${indentJson(value)}`);
+            }
+        }
+        if (this.failure !== null) {
+            fields.push(`failure=${indentJson(this.failure)}`);
+        }
+        return `Job(${fields.map((field) => `\n${REPR_INDENT}${field},`).join("")}\n)`;
+    }
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.toString();
+    }
+}
+exports.Job = Job;
+const REPR_INDENT = "    ";
+// biome-ignore lint/suspicious/noExplicitAny: shape varies by job type
+function indentJson(value) {
+    return JSON.stringify(value, null, 4).replace(/\n/g, `\n${REPR_INDENT}`);
+}
+// biome-ignore lint/suspicious/noExplicitAny: shape varies by job type
+function parseJson(raw) {
+    return raw === null || raw === undefined ? null : JSON.parse(raw);
+}

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

@@ -14,6 +14,8 @@ export interface MaterializedViewDefinition {
     limit?: number;
     /** Source columns the projections and filter read. */
     inputs: string[];
+    /** Namespace holding the source table; empty is the root namespace. */
+    sourceNamespace: string[];
 }
 /**
  * The view's columns: column names, `[alias, SQL expression]` pairs, or a

package/dist/vendor/lancedb/materialized_view.js

@@ -44,7 +44,8 @@ function definitionFromMetadata(metadata, name) {
     }
     // biome-ignore lint/suspicious/noExplicitAny: raw JSON
     const value = JSON.parse(raw);
-    if (value.kind !== "select") {
+    // "namespaced_select" keeps older readers from resolving the source at root.
+    if (value.kind !== "select" && value.kind !== "namespaced_select") {
         throw new Error(`materialized view '${name}' is defined by '${value.kind}', which this ` +
             "version of lancedb cannot refresh");
     }
@@ -65,6 +66,7 @@ function definitionFromMetadata(metadata, name) {
         filter: value.filter ?? undefined,
         limit,
         inputs: value.inputs ?? [],
+        sourceNamespace: value.source_namespace ?? [],
     };
 }
 /**

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

@@ -15,7 +15,7 @@ export declare class MergeInsertBuilder {
      * but that behavior is subject to change.
      *
      * An optional condition may be specified.  If it is, then only
-     * matched rows that satisfy the condtion will be updated.  Any
+     * matched rows that satisfy the condition will be updated.  Any
      * rows that do not satisfy the condition will be left as they
      * are.  Failing to satisfy the condition does not cause a
      * "matched row" to become a "not matched" row.

package/dist/vendor/lancedb/merge.js

@@ -23,7 +23,7 @@ class MergeInsertBuilder {
      * but that behavior is subject to change.
      *
      * An optional condition may be specified.  If it is, then only
-     * matched rows that satisfy the condtion will be updated.  Any
+     * matched rows that satisfy the condition will be updated.  Any
      * rows that do not satisfy the condition will be left as they
      * are.  Failing to satisfy the condition does not cause a
      * "matched row" to become a "not matched" row.

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

@@ -1,5 +1,11 @@
 /* auto-generated by NAPI-RS */
 /* eslint-disable */
+export declare class BlobFile {
+  size(): bigint
+  read(): Promise<Buffer>
+  readRange(start: bigint, end: bigint): Promise<Buffer>
+}
+
 export declare class BranchContents {
   parentBranch?: string
   parentVersion: number
@@ -47,30 +53,21 @@ export declare class Connection {
   dropTableAsync(name: string, namespacePath?: Array<string> | undefined | null): Promise<Job>
   dropAllTables(namespacePath?: Array<string> | undefined | null): Promise<void>
   /**
-   * A `Job` handle for a server-side job by id.
+   * Open a server-side job by id, returning a handle with its record
+   * already populated. Rejects when the server has no such job.
    *
-   * The handle is constructed without a server round trip; an unknown id
-   * surfaces when the handle is used.
+   * The returned handle answers for its own state, specification, result,
+   * failure and event history, so there is no separate connection-level
+   * call for any of them.
    */
-  job(jobId: string): Job
+  openJob(jobId: string): Promise<Job>
   /** List server-side jobs across the database's tables. */
   listJobs(): Promise<Array<JobInfo>>
-  /**
-   * Describe a single server-side job by id. `null` when the server has
-   * no such job.
-   */
-  getJob(jobId: string): Promise<JobDescription | null>
   /**
    * Request cancellation of a server-side job by id. Returns true if the
    * server accepted the cancellation, false if no such job exists.
    */
   cancelJob(jobId: string): Promise<boolean>
-  /**
-   * The lifecycle event history of a server-side job (all jobs when
-   * `job_id` is null), as an Arrow IPC stream buffer. Empty when there is
-   * no history.
-   */
-  jobHistory(jobId?: string | undefined | null): Promise<Buffer>
   /** Describe a namespace and return its properties. */
   describeNamespace(namespacePath: Array<string>): Promise<DescribeNamespaceResponse>
   /** List child namespaces under the given namespace path */
@@ -120,6 +117,39 @@ export declare class Job {
   wait(): Promise<void>
   /** Request cancellation. Cancelling a finished operation is a no-op. */
   cancel(): Promise<void>
+  /**
+   * Ask the backend for this job's current state, and for a server-side job
+   * its full record, then cache it for the getters below.
+   *
+   * They are all null until this runs, because submitting an operation
+   * returns only a job id. {@link Job.status} fetches the whole record too;
+   * {@link Job.wait} records only the terminal state it establishes.
+   */
+  refresh(): Promise<void>
+  /** The last observed lifecycle state, without contacting the backend. */
+  get state(): string | null
+  /**
+   * The job's type, as the server names it. Null for an in-process job,
+   * which has no server-side record.
+   */
+  get jobType(): string | null
+  /** When the job was created, in milliseconds since the epoch. */
+  get creationMs(): number | null
+  /** The job-type-specific specification as a JSON string, when present. */
+  get specJson(): string | null
+  /**
+   * The job-type-specific terminal result as a JSON string. Null until the
+   * job succeeds, so a job that never terminates reports its progress
+   * through {@link Job.events} instead.
+   */
+  get resultJson(): string | null
+  /** Why the job failed, when it failed and the server reports a reason. */
+  get failure(): JobFailureInfo | null
+  /**
+   * This job's recorded lifecycle events, as an Arrow IPC stream buffer.
+   * The TypeScript wrapper turns it into an Arrow table.
+   */
+  events(limit?: number | undefined | null, filter?: string | undefined | null): Promise<Buffer>
 }
 
 export declare class JsFullTextQuery {
@@ -286,6 +316,9 @@ export declare class Table {
   querySnapshot(): Promise<Table>
   takeOffsets(offsets: Array<number>): TakeQuery
   takeRowIds(rowIds: Array<bigint>): TakeQuery
+  blobColumns(): Promise<Array<string>>
+  fetchBlobs(column: string, rowIds: Array<bigint>): Promise<Array<Buffer | undefined | null>>
+  fetchBlobFiles(column: string, rowIds: Array<bigint>): Promise<Array<BlobFile | undefined | null>>
   vectorSearch(vector: Float32Array): VectorQuery
   addColumns(transforms: Array<AddColumnsSql>): Promise<AddColumnsResult>
   addComputedColumns(columns: Array<AddColumnsSql>): Promise<AddColumnsResult>
@@ -316,7 +349,7 @@ export declare class Table {
   branches(): Promise<Branches>
   /** The branch this handle is scoped to, or `null` for the main branch. */
   currentBranch(): string | null
-  optimize(olderThanMs?: number | undefined | null, deleteUnverified?: boolean | undefined | null): Promise<OptimizeStats>
+  optimize(beforeTimestampMs?: number | undefined | null, deleteUnverified?: boolean | undefined | null): Promise<OptimizeStats>
   listIndices(): Promise<Array<IndexConfig>>
   tokenize(query: string, column?: string | undefined | null, indexName?: string | undefined | null): Promise<Array<FtsToken>>
   indexStats(indexName: string): Promise<IndexStatistics | null>
@@ -773,23 +806,6 @@ export interface IndexStatistics {
   numIndices?: number
 }
 
-/** A described job from `Connection.getJob`. */
-export interface JobDescription {
-  jobId: string
-  jobType: string
-  /** Lifecycle state: "running", "finished", "failed", or "cancelled". */
-  state: string
-  /** When the job was created, in milliseconds since the epoch. */
-  creationMs: number
-  /** The job-type-specific specification as a JSON string, when present. */
-  specJson?: string
-  /**
-   * Why the job failed, when the job is failed and the server reports a
-   * reason.
-   */
-  failure?: JobFailureInfo
-}
-
 /** The server's account of why a job failed. */
 export interface JobFailureInfo {
   phase?: string
@@ -800,7 +816,7 @@ export interface JobFailureInfo {
 /** A row from `Connection.listJobs`: one server-side job. */
 export interface JobInfo {
   /**
-   * The job id -- what `Connection.getJob` and `Connection.cancelJob`
+   * The job id -- what `Connection.openJob` and `Connection.cancelJob`
    * accept.
    */
   jobId: string