pi-crew 0.9.16 → 0.9.17

package/src/utils/bm25-search.ts

@@ -2,153 +2,153 @@ import type { AgentConfig } from "../agents/agent-config.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 
 interface SearchDocument {
-  id: string;
-  fields: Record<string, string>;
+	id: string;
+	fields: Record<string, string>;
 }
 
 interface SearchResult<T> {
-  item: T;
-  score: number;
-  matchedOn: string[];
+	item: T;
+	score: number;
+	matchedOn: string[];
 }
 
 interface BM25Config {
-  k1?: number;
-  b?: number;
+	k1?: number;
+	b?: number;
 }
 
 export class BM25Search<T extends SearchDocument> {
-  private readonly documents: T[];
-  private readonly fieldWeights: Record<string, number>;
-  private readonly avgDocLen: number;
-  private readonly k1: number;
-  private readonly b: number;
-  private readonly docLenMap: Map<string, number>;
-  private readonly N: number;
-  /**
-   * Precomputed document frequency per term. Cached at construction time
-   * to avoid O(N) recomputation on every search() call. The cache is
-   * immutable for a given document corpus, so it's safe to share across
-   * search() invocations.
-   */
-  private readonly dfCache: Map<string, number>;
-
-  constructor(documents: T[], fieldWeights: Record<string, number> = {}, config: BM25Config = {}) {
-    this.documents = documents;
-    this.fieldWeights = fieldWeights;
-    this.k1 = config.k1 ?? 1.5;
-    this.b = config.b ?? 0.75;
-    this.N = documents.length;
-
-    this.docLenMap = new Map();
-    this.dfCache = new Map();
-
-    for (const doc of documents) {
-      const fieldValues = Object.values(doc.fields).join(" ");
-      const len = fieldValues.split(/\s+/).filter(Boolean).length;
-      this.docLenMap.set(doc.id, len);
-    }
-
-    const totalLen = [...this.docLenMap.values()].reduce((a, b) => a + b, 0);
-    this.avgDocLen = totalLen / this.N || 1;
-
-    // Precompute df for all terms in the corpus. We do this once instead
-    // of on-demand to avoid the O(Q * N * field_count) cost per search call.
-    this.precomputeDocumentFrequencies();
-  }
-
-  /**
-   * Build a map of term -> document frequency. O(N * avg_terms * field_count).
-   * Called once in the constructor.
-   */
-  private precomputeDocumentFrequencies(): void {
-    for (const doc of this.documents) {
-      for (const field of Object.keys(this.fieldWeights)) {
-        const text = (doc.fields[field] ?? "").toLowerCase();
-        // Extract unique terms via split on whitespace
-        const terms = new Set(text.split(/\s+/).filter(Boolean));
-        for (const term of terms) {
-          if (term.length === 0) continue;
-          this.dfCache.set(term, (this.dfCache.get(term) ?? 0) + 1);
-        }
-      }
-    }
-  }
-
-  /**
-   * Get document frequency for a term. Returns the precomputed value.
-   * O(1) lookup.
-   */
-  private df(term: string): number {
-    return this.dfCache.get(term.toLowerCase()) ?? 0;
-  }
-
-  search(query: string, options?: { limit?: number; minScore?: number }): SearchResult<T>[] {
-    const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
-    if (queryTerms.length === 0) return [];
-
-    const results: SearchResult<T>[] = [];
-
-    for (const doc of this.documents) {
-      let totalScore = 0;
-      const matchedOn: string[] = [];
-
-      for (const [field, weight] of Object.entries(this.fieldWeights)) {
-        const text = doc.fields[field] ?? "";
-        const textLower = text.toLowerCase();
-        let fieldScore = 0;
-
-        for (const term of queryTerms) {
-          // Use indexOf for linear-time substring counting instead of regex
-          const termLower = term.toLowerCase();
-          let tf = 0;
-          let pos = 0;
-          while ((pos = textLower.indexOf(termLower, pos)) !== -1) {
-            tf++;
-            pos += termLower.length;
-            // Cap tf to prevent runaway on repeated patterns
-            if (tf > 100) break;
-          }
-          if (tf === 0) continue;
-
-          const df = this.df(termLower);
-          if (df === 0) continue;
-
-          const idf = Math.log((this.N - df + 0.5) / (df + 0.5) + 1);
-          const docLen = this.docLenMap.get(doc.id) ?? this.avgDocLen;
-          const numerator = tf * (this.k1 + 1);
-          const denominator = tf + this.k1 * (1 - this.b + this.b * docLen / this.avgDocLen);
-          fieldScore += idf * (numerator / denominator);
-
-          matchedOn.push(field);
-        }
-
-        totalScore += fieldScore * (weight || 1);
-      }
-
-      if (totalScore > 0) {
-        results.push({
-          item: doc,
-          score: totalScore,
-          matchedOn: [...new Set(matchedOn)],
-        });
-      }
-    }
-
-    results.sort((a, b) => b.score - a.score);
-
-    const limit = options?.limit ?? 10;
-    const minScore = options?.minScore ?? 0.01;
-
-    return results.filter((r) => r.score >= minScore).slice(0, limit);
-  }
+	private readonly documents: T[];
+	private readonly fieldWeights: Record<string, number>;
+	private readonly avgDocLen: number;
+	private readonly k1: number;
+	private readonly b: number;
+	private readonly docLenMap: Map<string, number>;
+	private readonly N: number;
+	/**
+	 * Precomputed document frequency per term. Cached at construction time
+	 * to avoid O(N) recomputation on every search() call. The cache is
+	 * immutable for a given document corpus, so it's safe to share across
+	 * search() invocations.
+	 */
+	private readonly dfCache: Map<string, number>;
+
+	constructor(documents: T[], fieldWeights: Record<string, number> = {}, config: BM25Config = {}) {
+		this.documents = documents;
+		this.fieldWeights = fieldWeights;
+		this.k1 = config.k1 ?? 1.5;
+		this.b = config.b ?? 0.75;
+		this.N = documents.length;
+
+		this.docLenMap = new Map();
+		this.dfCache = new Map();
+
+		for (const doc of documents) {
+			const fieldValues = Object.values(doc.fields).join(" ");
+			const len = fieldValues.split(/\s+/).filter(Boolean).length;
+			this.docLenMap.set(doc.id, len);
+		}
+
+		const totalLen = [...this.docLenMap.values()].reduce((a, b) => a + b, 0);
+		this.avgDocLen = totalLen / this.N || 1;
+
+		// Precompute df for all terms in the corpus. We do this once instead
+		// of on-demand to avoid the O(Q * N * field_count) cost per search call.
+		this.precomputeDocumentFrequencies();
+	}
+
+	/**
+	 * Build a map of term -> document frequency. O(N * avg_terms * field_count).
+	 * Called once in the constructor.
+	 */
+	private precomputeDocumentFrequencies(): void {
+		for (const doc of this.documents) {
+			for (const field of Object.keys(this.fieldWeights)) {
+				const text = (doc.fields[field] ?? "").toLowerCase();
+				// Extract unique terms via split on whitespace
+				const terms = new Set(text.split(/\s+/).filter(Boolean));
+				for (const term of terms) {
+					if (term.length === 0) continue;
+					this.dfCache.set(term, (this.dfCache.get(term) ?? 0) + 1);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Get document frequency for a term. Returns the precomputed value.
+	 * O(1) lookup.
+	 */
+	private df(term: string): number {
+		return this.dfCache.get(term.toLowerCase()) ?? 0;
+	}
+
+	search(query: string, options?: { limit?: number; minScore?: number }): SearchResult<T>[] {
+		const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+		if (queryTerms.length === 0) return [];
+
+		const results: SearchResult<T>[] = [];
+
+		for (const doc of this.documents) {
+			let totalScore = 0;
+			const matchedOn: string[] = [];
+
+			for (const [field, weight] of Object.entries(this.fieldWeights)) {
+				const text = doc.fields[field] ?? "";
+				const textLower = text.toLowerCase();
+				let fieldScore = 0;
+
+				for (const term of queryTerms) {
+					// Use indexOf for linear-time substring counting instead of regex
+					const termLower = term.toLowerCase();
+					let tf = 0;
+					let pos = 0;
+					while ((pos = textLower.indexOf(termLower, pos)) !== -1) {
+						tf++;
+						pos += termLower.length;
+						// Cap tf to prevent runaway on repeated patterns
+						if (tf > 100) break;
+					}
+					if (tf === 0) continue;
+
+					const df = this.df(termLower);
+					if (df === 0) continue;
+
+					const idf = Math.log((this.N - df + 0.5) / (df + 0.5) + 1);
+					const docLen = this.docLenMap.get(doc.id) ?? this.avgDocLen;
+					const numerator = tf * (this.k1 + 1);
+					const denominator = tf + this.k1 * (1 - this.b + (this.b * docLen) / this.avgDocLen);
+					fieldScore += idf * (numerator / denominator);
+
+					matchedOn.push(field);
+				}
+
+				totalScore += fieldScore * (weight || 1);
+			}
+
+			if (totalScore > 0) {
+				results.push({
+					item: doc,
+					score: totalScore,
+					matchedOn: [...new Set(matchedOn)],
+				});
+			}
+		}
+
+		results.sort((a, b) => b.score - a.score);
+
+		const limit = options?.limit ?? 10;
+		const minScore = options?.minScore ?? 0.01;
+
+		return results.filter((r) => r.score >= minScore).slice(0, limit);
+	}
 }
 
 // Agent search interface
 interface AgentSearchResult {
-  agent: AgentConfig;
-  score: number;
-  matchedOn: string[];
+	agent: AgentConfig;
+	score: number;
+	matchedOn: string[];
 }
 
 /**
@@ -156,44 +156,44 @@ interface AgentSearchResult {
  * Uses dynamic import to avoid ESM/CJS issues at module load time.
  */
 export async function searchAgents(query: string, options?: { limit?: number }): Promise<AgentSearchResult[]> {
-		// LAZY: defer dynamic import of ../agents/discover-agents.ts to its call site.
-  const { discoverAgents, allAgents } = await import("../agents/discover-agents.ts");
-  const discovery = discoverAgents(process.cwd());
-  const all = allAgents(discovery);
-
-  const docs: (SearchDocument & { agent: AgentConfig })[] = all.map((agent: AgentConfig) => ({
-    id: agent.name,
-    fields: {
-      name: agent.name,
-      description: agent.description ?? "",
-      skills: (agent.skills ?? []).join(" "),
-    },
-    agent,
-  }));
-
-  const engine = new BM25Search(docs, {
-    name: 3.0,
-    description: 1.5,
-    skills: 1.0,
-  });
-
-  const results = engine.search(query, {
-    limit: options?.limit ?? 10,
-    minScore: 0.1,
-  });
-
-  return results.map((r) => ({
-    agent: r.item.agent,
-    score: r.score,
-    matchedOn: r.matchedOn,
-  }));
+	// LAZY: defer dynamic import of ../agents/discover-agents.ts to its call site.
+	const { discoverAgents, allAgents } = await import("../agents/discover-agents.ts");
+	const discovery = discoverAgents(process.cwd());
+	const all = allAgents(discovery);
+
+	const docs: (SearchDocument & { agent: AgentConfig })[] = all.map((agent: AgentConfig) => ({
+		id: agent.name,
+		fields: {
+			name: agent.name,
+			description: agent.description ?? "",
+			skills: (agent.skills ?? []).join(" "),
+		},
+		agent,
+	}));
+
+	const engine = new BM25Search(docs, {
+		name: 3.0,
+		description: 1.5,
+		skills: 1.0,
+	});
+
+	const results = engine.search(query, {
+		limit: options?.limit ?? 10,
+		minScore: 0.1,
+	});
+
+	return results.map((r) => ({
+		agent: r.item.agent,
+		score: r.score,
+		matchedOn: r.matchedOn,
+	}));
 }
 
 // Team search interface
 interface TeamSearchResult {
-  team: TeamConfig;
-  score: number;
-  matchedOn: string[];
+	team: TeamConfig;
+	score: number;
+	matchedOn: string[];
 }
 
 /**
@@ -201,35 +201,35 @@ interface TeamSearchResult {
  * Uses dynamic import to avoid ESM/CJS issues at module load time.
  */
 export async function searchTeams(query: string, options?: { limit?: number }): Promise<TeamSearchResult[]> {
-		// LAZY: defer dynamic import of ../teams/discover-teams.ts to its call site.
-  const { discoverTeams, allTeams } = await import("../teams/discover-teams.ts");
-  const discovery = discoverTeams(process.cwd());
-  const all = allTeams(discovery);
-
-  const docs: (SearchDocument & { team: TeamConfig })[] = all.map((team: TeamConfig) => ({
-    id: team.name,
-    fields: {
-      name: team.name,
-      description: team.description ?? "",
-      roles: (team.roles ?? []).map((r: { name: string }) => r.name).join(" "),
-    },
-    team,
-  }));
-
-  const engine = new BM25Search(docs, {
-    name: 2.0,
-    description: 1.5,
-    roles: 1.0,
-  });
-
-  const results = engine.search(query, {
-    limit: options?.limit ?? 5,
-    minScore: 0.1,
-  });
-
-  return results.map((r) => ({
-    team: r.item.team,
-    score: r.score,
-    matchedOn: r.matchedOn,
-  }));
+	// LAZY: defer dynamic import of ../teams/discover-teams.ts to its call site.
+	const { discoverTeams, allTeams } = await import("../teams/discover-teams.ts");
+	const discovery = discoverTeams(process.cwd());
+	const all = allTeams(discovery);
+
+	const docs: (SearchDocument & { team: TeamConfig })[] = all.map((team: TeamConfig) => ({
+		id: team.name,
+		fields: {
+			name: team.name,
+			description: team.description ?? "",
+			roles: (team.roles ?? []).map((r: { name: string }) => r.name).join(" "),
+		},
+		team,
+	}));
+
+	const engine = new BM25Search(docs, {
+		name: 2.0,
+		description: 1.5,
+		roles: 1.0,
+	});
+
+	const results = engine.search(query, {
+		limit: options?.limit ?? 5,
+		minScore: 0.1,
+	});
+
+	return results.map((r) => ({
+		team: r.item.team,
+		score: r.score,
+		matchedOn: r.matchedOn,
+	}));
 }

package/src/utils/conflict-detect.ts

@@ -73,7 +73,11 @@ export function scanConflictLines(lines: readonly string[], firstLineNumber: num
 
 		const oursLabel = matchMarker(line, OURS_PREFIX);
 		if (oursLabel !== null) {
-			partial = { startLine: ln, oursLabel: oursLabel || undefined, oursLines: [] };
+			partial = {
+				startLine: ln,
+				oursLabel: oursLabel || undefined,
+				oursLines: [],
+			};
 			phase = "ours";
 			continue;
 		}
@@ -318,9 +322,7 @@ export function parseConflictUri(raw: string): ParsedConflictUri | null {
 	let scope: ConflictScope | undefined;
 	if (scopePart !== undefined) {
 		if (!CONFLICT_SCOPES.has(scopePart as ConflictScope)) {
-			throw new Error(
-				`Invalid conflict URI '${raw}': scope must be one of 'ours', 'theirs', 'base', or omitted.`,
-			);
+			throw new Error(`Invalid conflict URI '${raw}': scope must be one of 'ours', 'theirs', 'base', or omitted.`);
 		}
 		scope = scopePart as ConflictScope;
 	}
@@ -375,7 +377,10 @@ function locateRegion(
 	if (expected.length === 0 || expected.length > lines.length) return null;
 	// Fast path: try the recorded position first.
 	if (preferredIdx >= 0 && matchesAt(lines, preferredIdx, expected)) {
-		return { startIdx: preferredIdx, endIdx: preferredIdx + expected.length - 1 };
+		return {
+			startIdx: preferredIdx,
+			endIdx: preferredIdx + expected.length - 1,
+		};
 	}
 	let best: number | null = null;
 	let bestDist = Number.POSITIVE_INFINITY;
@@ -462,15 +467,15 @@ function markerLine(prefix: string, label: string | undefined): string {
  * - `startLine`: the 1-indexed file line number `lines[0]` corresponds
  *   to, so the read formatter can label hashline anchors.
  */
-export function renderConflictRegion(
-	entry: ConflictEntry,
-	scope: ConflictScope | undefined,
-): { lines: string[]; startLine: number } {
+export function renderConflictRegion(entry: ConflictEntry, scope: ConflictScope | undefined): { lines: string[]; startLine: number } {
 	if (scope === "ours") {
 		return { lines: [...entry.oursLines], startLine: entry.startLine + 1 };
 	}
 	if (scope === "theirs") {
-		return { lines: [...entry.theirsLines], startLine: entry.separatorLine + 1 };
+		return {
+			lines: [...entry.theirsLines],
+			startLine: entry.separatorLine + 1,
+		};
 	}
 	if (scope === "base") {
 		if (entry.baseLines === undefined || entry.baseLine === undefined) {
@@ -495,10 +500,7 @@ export function renderConflictRegion(
 
 const PREVIEW_SIDE_LINES = 6;
 
-function pickLabel(
-	entries: readonly ConflictEntry[],
-	get: (e: ConflictEntry) => string | undefined,
-): string | undefined {
+function pickLabel(entries: readonly ConflictEntry[], get: (e: ConflictEntry) => string | undefined): string | undefined {
 	for (const e of entries) {
 		const label = get(e);
 		if (label && label.trim().length > 0) return label;
@@ -552,10 +554,7 @@ export interface FormatConflictWarningOptions {
  *     >>> theirs
  *     …theirs body…
  */
-export function formatConflictWarning(
-	entries: readonly ConflictEntry[],
-	options: FormatConflictWarningOptions = {},
-): string {
+export function formatConflictWarning(entries: readonly ConflictEntry[], options: FormatConflictWarningOptions = {}): string {
 	if (entries.length === 0) return "";
 	const total = options.totalInFile ?? entries.length;
 	const partial = total > entries.length;
@@ -585,7 +584,7 @@ export function formatConflictWarning(
 		'NOTICE: Inspect a block by reading `conflict://<N>` (add `/ours` / `/theirs` / `/base` to render a single side). Resolve with `write({ path: "conflict://<N>", content })`, or bulk-resolve every registered conflict with `write({ path: "conflict://*", content })`.',
 	);
 	out.push(
-		'`content` shorthand: a line that is exactly `@ours` / `@theirs` / `@base` / `@both` expands to that recorded section. Non-token lines pass through verbatim.',
+		"`content` shorthand: a line that is exactly `@ours` / `@theirs` / `@base` / `@both` expands to that recorded section. Non-token lines pass through verbatim.",
 	);
 
 	for (const entry of entries) {
@@ -627,7 +626,9 @@ export function formatConflictWarning(
  */
 export function formatConflictSummary(
 	entries: readonly ConflictEntry[],
-	options: { displayPath: string; scanTruncated?: boolean } = { displayPath: "" },
+	options: { displayPath: string; scanTruncated?: boolean } = {
+		displayPath: "",
+	},
 ): string {
 	const lines: string[] = [];
 	const total = entries.length;
@@ -658,4 +659,4 @@ export function formatConflictSummary(
 		lines.push(`${idCell}  ${range}${kind}`);
 	}
 	return lines.join("\n");
-}
+}

package/src/utils/env-filter.ts

@@ -5,13 +5,20 @@ import { isSecretKey } from "./redaction.ts";
 // These are "secret" by pattern (contain KEY/API) but are safe to allowlist
 // because they are standard provider credentials, not arbitrary secrets.
 const KNOWN_PROVIDER_KEYS = new Set([
-	"MINIMAX_API_KEY", "MINIMAX_GROUP_ID",
-	"OPENAI_API_KEY", "OPENAI_ORG_ID",
+	"MINIMAX_API_KEY",
+	"MINIMAX_GROUP_ID",
+	"OPENAI_API_KEY",
+	"OPENAI_ORG_ID",
 	"ANTHROPIC_API_KEY",
-	"GOOGLE_API_KEY", "GOOGLE_GENERATIVE_LANGUAGE_API_KEY",
-	"AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT",
-	"AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION",
-	"ZEU_API_KEY", "ZERODEV_API_KEY",
+	"GOOGLE_API_KEY",
+	"GOOGLE_GENERATIVE_LANGUAGE_API_KEY",
+	"AZURE_OPENAI_API_KEY",
+	"AZURE_OPENAI_ENDPOINT",
+	"AWS_ACCESS_KEY_ID",
+	"AWS_SECRET_ACCESS_KEY",
+	"AWS_REGION",
+	"ZEU_API_KEY",
+	"ZERODEV_API_KEY",
 ]);
 
 function isKnownProviderKey(key: string): boolean {
@@ -96,4 +103,4 @@ export function sanitizeEnvSecrets(env: NodeJS.ProcessEnv, options?: SanitizeEnv
 		if (value !== undefined && !isSecretKey(key)) filtered[key] = value;
 	}
 	return filtered;
-}
+}

package/src/utils/file-coalescer.ts

@@ -23,7 +23,11 @@ export interface FileCoalescer {
 	clear(): void;
 }
 
-export function createFileCoalescer(handler: (file: string) => void, defaultDelayMs: number, timerApi: TimerApi = defaultTimerApi): FileCoalescer {
+export function createFileCoalescer(
+	handler: (file: string) => void,
+	defaultDelayMs: number,
+	timerApi: TimerApi = defaultTimerApi,
+): FileCoalescer {
 	const pending = new Map<string, unknown>();
 	return {
 		schedule(file, delayMs = defaultDelayMs) {

package/src/utils/fingerprint.ts

@@ -8,7 +8,7 @@
  */
 
 import { createHash, type Hash } from "node:crypto";
-import { readFileSync, writeFileSync, existsSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { logInternalError } from "../utils/internal-error.ts";
 
 // ── Types ────────────────────────────────────────────────────────────────
@@ -66,7 +66,7 @@ export function computeStructuralSignature(content: string, filePath: string): s
 		if (
 			// Function/method declarations
 			/^(export\s+)?(async\s+)?function\s/.test(trimmed) ||
-			/^\w+\s*\(/.test(trimmed) && !/^(if|for|while|switch|return|throw|await)/.test(trimmed) ||
+			(/^\w+\s*\(/.test(trimmed) && !/^(if|for|while|switch|return|throw|await)/.test(trimmed)) ||
 			// Class declarations
 			/^(export\s+)?(abstract\s+)?class\s/.test(trimmed) ||
 			/^(public|private|protected|static|readonly|abstract)\s/.test(trimmed) ||
@@ -147,10 +147,7 @@ export function saveFingerprintBaseline(storePath: string, fingerprints: Map<str
  *
  * Only returns STRUCTURAL changes in the `modified` field.
  */
-export function computeFingerprintDelta(
-	baseline: Map<string, FileFingerprint>,
-	current: Map<string, FileFingerprint>,
-): FingerprintDelta {
+export function computeFingerprintDelta(baseline: Map<string, FileFingerprint>, current: Map<string, FileFingerprint>): FingerprintDelta {
 	const added: string[] = [];
 	const removed: string[] = [];
 	const modified: FileFingerprint[] = [];

package/src/utils/frontmatter.ts

@@ -44,7 +44,9 @@ function parseLines(raw: string): Record<string, string> {
 export function parseCsv(value: string | undefined): string[] | undefined {
 	if (value === undefined) return undefined;
 	// Handle quoted values with commas inside.
-	const values = splitCsv(value).map((item) => item.trim()).filter(Boolean);
+	const values = splitCsv(value)
+		.map((item) => item.trim())
+		.filter(Boolean);
 	return values.length > 0 ? [...new Set(values)] : undefined;
 }
 

package/src/utils/fs-watch.ts

@@ -1,5 +1,5 @@
-import * as fs from "node:fs";
 import type { FSWatcher, WatchListener } from "node:fs";
+import * as fs from "node:fs";
 
 /**
  * Filesystem watcher helpers (slimmed down — pts/2 hang fix 2026-06-16).
@@ -25,11 +25,7 @@ export function closeWatcher(watcher: FSWatcher | null | undefined): void {
 	}
 }
 
-export function watchWithErrorHandler(
-	path: string,
-	listener: WatchListener<string>,
-	onError: (error?: unknown) => void,
-): FSWatcher | null {
+export function watchWithErrorHandler(path: string, listener: WatchListener<string>, onError: (error?: unknown) => void): FSWatcher | null {
 	try {
 		const watcher = fs.watch(path, listener);
 		watcher.on("error", onError);