@estebanforge/pi-antigravity-bridge 1.3.0 → 1.3.2

package/src/protobuf.ts

@@ -1,184 +0,0 @@
-// Hand-rolled protobuf decoder for agy's `step_payload` blobs.
-//
-// agy writes per-conversation SQLite DBs at ~/.gemini/antigravity-cli/
-// conversations/<uuid>.db. The `steps.step_payload` column is a protobuf blob
-// with NO published schema. Field numbers below are load-bearing
-// reverse-engineered facts (cross-checked against the shindgew/agy-acp and
-// shubzkothekar/antigravity-acp decoders, plus real DB inspection on this
-// machine, agy v1.1.7).
-//
-// We hand-roll the varint walker instead of pulling @bufbuild/protobuf or
-// generating from .proto. The openab/agy-acp Rust port proves ~94 lines is
-// enough for text + tool name extraction. Unknown fields are skipped per
-// protobuf wire-format rules, so a future agy that adds fields won't break us.
-//
-// Layout we care about:
-//   step_payload:
-//     field 20 (submessage) = agentText   { 1: text }
-//     field  5 (submessage) = toolRun     { 4: toolCall { 2|9: name, 3: inputJson } }
-//     field 30 (submessage) = titleUpdate { 4: title }
-// (fuller map in decodeStepPayload  -  only the ones we stream to pi.)
-
-export type ByteSource = Uint8Array | ArrayBufferLike;
-
-/** Read a base-128 varint starting at offset `i`. Returns [value, nextOffset].
- *
- *  NOTE on precision: accumulation uses bitwise OR and shift, which are
- *  32-bit operations in JS. Values needing 5+ continuation bytes (>32 bits)
- *  are truncated, not decoded correctly. This is acceptable here because agy
- *  field numbers and payload lengths are always small (well under 2^32). The
- *  10-byte cap is a DoS guard (stop a corrupt blob spinning forever), not a
- *  correctness guarantee for the full 64-bit varint range. */
-export function readVarint(buf: Uint8Array, i: number): [number, number] {
-	let result = 0;
-	let shift = 0;
-	let offset = i;
-	// protobuf caps varints at 10 bytes (64-bit). Cap the loop so a corrupt
-	// blob can't spin forever.
-	for (let count = 0; count < 10; count++) {
-		if (offset >= buf.length) {
-			throw new RangeError(`varint at ${i} ran past end of buffer`);
-		}
-		const byte = buf[offset++];
-		result |= (byte & 0x7f) << shift;
-		if ((byte & 0x80) === 0) return [result >>> 0, offset];
-		shift += 7;
-	}
-	throw new RangeError(`varint at ${i} exceeded 10 bytes`);
-}
-
-/** A (fieldNumber, wireType, valueSlice) triple produced by walking one field.
- *  For length-delimited fields (wire 2), `bytes` is the field payload.
- *  For varints (wire 0), `varint` holds the value. */
-export interface Field {
-	field: number;
-	wire: number;
-	bytes: Uint8Array | null; // wire 2 payload (view into the source buffer)
-	varint: number | null; // wire 0 value
-}
-
-/** Walk every top-level field in a protobuf message. Returns the fields in
- *  order. Packed/repeated fields are not collapsed  -  callers see each
- *  occurrence. Unknown fields are included so the walker is reusable. */
-export function walkFields(buf: Uint8Array): Field[] {
-	const out: Field[] = [];
-	let i = 0;
-	while (i < buf.length) {
-		const [tag, afterTag] = readVarint(buf, i);
-		i = afterTag;
-		const field = tag >>> 3;
-		const wire = tag & 0x07;
-		if (wire === 0) {
-			// varint
-			const [val, after] = readVarint(buf, i);
-			i = after;
-			out.push({ field, wire, bytes: null, varint: val });
-		} else if (wire === 2) {
-			// length-delimited
-			const [len, afterLen] = readVarint(buf, i);
-			i = afterLen;
-			if (i + len > buf.length) {
-				throw new RangeError(`field ${field}: length ${len} runs past buffer end`);
-			}
-			// subarray is a VIEW into the same backing buffer (no copy). Safe here
-			// because the view is decoded and discarded within this poll; do NOT
-			// retain `Field.bytes` past the current call  -  the source buffer may
-			// be reused or collected differently than a retained slice expects.
-			out.push({ field, wire, bytes: buf.subarray(i, i + len), varint: null });
-			i += len;
-		} else if (wire === 5) {
-			// fixed32
-			out.push({ field, wire, bytes: null, varint: null });
-			i += 4;
-		} else if (wire === 1) {
-			// fixed64
-			out.push({ field, wire, bytes: null, varint: null });
-			i += 8;
-		} else {
-			// wire 3/4 (start/end group) are deprecated and agy never emits them.
-			// Throw rather than silently drop every field after this point  -  a
-			// corrupt byte that looks like a group delimiter should fail loudly so
-			// the caller (pollOnce) can drop the step and retry on the next poll.
-			throw new RangeError(`unexpected wire type ${wire} at field ${field}`);
-		}
-	}
-	return out;
-}
-
-/** Find the first length-delimited field with the given number, or null.
- *  Equivalent to agy-acp's readSubmessage + readMessage dispatch for one field. */
-export function getField(buf: Uint8Array, target: number): Uint8Array | null {
-	for (const f of walkFields(buf)) {
-		if (f.field === target && f.wire === 2 && f.bytes) return f.bytes;
-	}
-	return null;
-}
-
-/** Decode a UTF-8 slice to a string. Tolerant: invalid bytes become U+FFFD. */
-const utf8 = new TextDecoder("utf-8", { fatal: false });
-export function utf8String(bytes: Uint8Array): string {
-	return utf8.decode(bytes);
-}
-
-export interface AgentText {
-	text: string;
-}
-
-export interface ToolCallInfo {
-	/** Primary tool name (field 2 of toolCall). */
-	name: string;
-	/** Raw input JSON string (field 3 of toolCall), unparsed. */
-	inputJson: string;
-}
-
-/** Extract agent text from a step_payload: field 20 -> field 1.
- *  Returns null if the payload has no agentText field. */
-export function extractAgentText(payload: Uint8Array): AgentText | null {
-	const agentText = getField(payload, 20);
-	if (!agentText) return null;
-	const text = getField(agentText, 1);
-	if (!text) return null;
-	return { text: utf8String(text) };
-}
-
-/** Extract tool-call info from a step_payload: field 5 (toolRun) -> field 4
- *  (toolCall) -> fields 2/9 (name) and 3 (inputJson). Returns null if the
- *  payload has no toolRun.toolCall. */
-export function extractToolCall(payload: Uint8Array): ToolCallInfo | null {
-	const toolRun = getField(payload, 5);
-	if (!toolRun) return null;
-	const toolCall = getField(toolRun, 4);
-	if (!toolCall) return null;
-	// Name lives at field 2 (namePrimary) or field 9 (nameSecondary).
-	let name = "";
-	let inputJson = "";
-	for (const f of walkFields(toolCall)) {
-		if (f.field === 2 && f.bytes) name ||= utf8String(f.bytes);
-		else if (f.field === 9 && f.bytes && !name) name = utf8String(f.bytes);
-		else if (f.field === 3 && f.bytes) inputJson ||= utf8String(f.bytes);
-	}
-	if (!name && !inputJson) return null;
-	return { name, inputJson };
-}
-
-/** Extract the title from a step_payload: field 30 (titleUpdate) -> field 4.
- *  Returns null when absent. */
-export function extractTitle(payload: Uint8Array): string | null {
-	const titleUpdate = getField(payload, 30);
-	if (!titleUpdate) return null;
-	const title = getField(titleUpdate, 4);
-	return title ? utf8String(title) : null;
-}
-
-/** Decode a Buffer/Uint8Array-shaped column value to a clean Uint8Array.
- *  node:sqlite returns Uint8Array for BLOB; better-sqlite3 returns Buffer. */
-export function toUint8(v: unknown): Uint8Array {
-	if (v instanceof Uint8Array) return v;
-	// Buffer is a Uint8Array subclass; instanceof covers it but be defensive.
-	if (ArrayBuffer.isView(v)) {
-		const view = v as Uint8Array;
-		return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
-	}
-	if (v == null) return new Uint8Array(0);
-	return new Uint8Array(0);
-}

package/src/runner.ts

@@ -1,390 +0,0 @@
-// Core agy turn runner: spawn `agy -p`, poll its conversation DB for new steps,
-// decode each, and emit structured events via a callback. Shared by the
-// standalone CLI (scripts/run-agy.ts) and the pi provider (src/provider.ts).
-//
-// Streaming contract:
-//   - agy writes steps to SQLite incrementally as it works.
-//   - We poll the DB every POLL_INTERVAL_MS (250), decode new rows, emit.
-//   - After agy exits, TRAILING_POLLS x 100ms catch late flushes.
-//   - agy does NOT print the conversation id; we bind it by snapshot/diff
-//     (see discovery.ts).
-//
-// agy runs its OWN closed tool loop (read/write/edit/exec against --add-dir).
-// We cannot bridge those tools to pi. Tool steps surface as "tool" events so
-// the UI can show "agy: editing foo.ts"  -  the edit itself already landed.
-
-import { spawn, type ChildProcess } from "node:child_process";
-import { bridgeMcpConfigDir, bridgeMcpConfigExists } from "./mcp-server.js";
-import { ConversationPoller, type Step } from "./poller.js";
-import {
-	CONVERSATIONS_DIR,
-	conversationDbPath,
-	newConversationId,
-	snapshotConversations,
-} from "./discovery.js";
-import { extractAgentText, extractToolCall, extractTitle } from "./protobuf.js";
-
-// --- tuning -----------------------------------------------------------------
-
-export const POLL_INTERVAL_MS = 250;
-export const TRAILING_POLLS = 3;
-export const TRAILING_POLL_MS = 100;
-export const DEFAULT_TIMEOUT_MIN = 10;
-const GRACE_AFTER_TIMEOUT_MS = 5000;
-// Cap on poll-tick retries to bind the conversation id when the snapshot is
-// ambiguous (a concurrent agy also created a .db). Each retry can run a full
-// /proc FD scan, so we stop after this many ticks (~15s at 250ms) and let the
-// turn fail safe rather than scan indefinitely. Generous enough to cover a
-// slow agy startup (OAuth refresh + cold init).
-const MAX_BIND_ATTEMPTS = 60;
-
-// agy conversation ids are UUID DB-stems. First char must be alphanumeric so a
-// leading-dash value can't misbind on agy's arg parser as the token after
-// --conversation (flag injection). Hyphens allowed in the body (real UUIDs).
-const CONV_ID_RE = /^[A-Za-z0-9][A-Za-z0-9-]{0,127}$/;
-
-// --- events -----------------------------------------------------------------
-
-export type AgyEvent =
-	| { kind: "text"; text: string }
-	| { kind: "thinking"; text: string }
-	| { kind: "tool"; name: string; inputJson: string }
-	| { kind: "title"; title: string };
-
-// step_type values observed in real DBs. Tool steps share the same payload
-// layout (field 5 -> toolCall), so we decode them uniformly. Unknown types
-// are skipped (return null)  -  forward-compatible with future agy additions.
-const TOOL_STEP_TYPES = new Set([5, 7, 8, 9, 17, 21, 33, 101, 132, 138]);
-
-/** Map a raw step row to a decoded event, or null when nothing to emit.
- *  Pure: no I/O, no side effects. Exported for testing. */
-export function decodeStep(step: Step): AgyEvent | null {
-	if (step.stepType === 15) {
-		const t = extractAgentText(step.payload);
-		return t ? { kind: "text", text: t.text } : null;
-	}
-	if (step.stepType === 14) {
-		// Thinking steps reuse the agentText layout (field 20.1) in observed DBs.
-		const t = extractAgentText(step.payload);
-		return t ? { kind: "thinking", text: t.text } : null;
-	}
-	if (step.stepType === 23) {
-		const title = extractTitle(step.payload);
-		return title ? { kind: "title", title } : null;
-	}
-	if (TOOL_STEP_TYPES.has(step.stepType)) {
-		const tc = extractToolCall(step.payload);
-		if (tc?.name) return { kind: "tool", name: tc.name, inputJson: tc.inputJson };
-		return null;
-	}
-	return null;
-}
-
-// --- options + result -------------------------------------------------------
-
-export interface AgyRunOptions {
-	/** Workspace root agy operates in (passed as --add-dir). */
-	cwd: string;
-	/** Exact agy model string, e.g. "Gemini 3.6 Flash (Medium)". Caller
-	 *  resolves aliases; the runner passes this through verbatim. */
-	model?: string;
-	/** Reasoning effort passed to agy --effort (low|medium|high). Omit to let
-	 *  the model slug's own effort stand (requires agy >= 1.1.5). */
-	effort?: "low" | "medium" | "high";
-	/** agy execution mode. accept-edits = agy applies edits; plan = review-only. */
-	mode?: "accept-edits" | "plan";
-	/** Pass --dangerously-skip-permissions so commands don't hang on an
-	 *  unanswerable y/n prompt in non-interactive `-p` mode. Default true.
-	 *  Required for accept-edits to function; harmless under plan mode. */
-	skipPermissions?: boolean;
-	/** The prompt. Required. */
-	prompt: string;
-	/** Existing conversation id to resume. When set, agy reuses it (no snapshot). */
-	conversationId?: string | null;
-	/** Highest step idx already streamed in a prior turn (resume only). The
-	 *  poller starts reading AFTER this idx so resumed turns don't replay
-	 *  history. Default -1 (read everything). */
-	baseStepIdx?: number;
-	/** Hard cap on the run, in minutes. */
-	timeoutMin?: number;
-	/** Optional AbortSignal for cancellation. */
-	signal?: AbortSignal;
-	/** Conversations dir override (testing / isolation). */
-	conversationsDir?: string;
-	/** agy binary path. Defaults to AGY_BIN env or "agy". */
-	binary?: string;
-	/** Extra args appended (split from AGY_EXTRA_ARGS by the caller). */
-	extraArgs?: string[];
-}
-
-export interface AgyRunResult {
-	exitCode: number;
-	conversationId: string | null;
-	lastIdx: number;
-	aborted: boolean;
-	timedOut: boolean;
-	stderr: string;
-	durationMs: number;
-}
-
-// --- spawn helpers ----------------------------------------------------------
-
-function resolveBinary(explicit?: string): string {
-	return explicit || process.env.AGY_BIN || "agy";
-}
-
-function extraArgsFromEnv(): string[] {
-	const raw = process.env.AGY_EXTRA_ARGS;
-	return raw ? raw.split(/\s+/).filter((s) => s.length > 0) : [];
-}
-
-const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
-
-// --- the turn ---------------------------------------------------------------
-
-/** Spawn agy and stream decoded events until it exits. Calls `onEvent` for
- *  every decoded step in order. Returns the run outcome (exit code, discovered
- *  conversation id, last step idx seen). Never throws on agy failure  - 
- *  surfaces non-zero exit / timeout / abort in the result. */
-export async function runAgyTurn(
-	opts: AgyRunOptions,
-	onEvent: (event: AgyEvent) => void,
-): Promise<AgyRunResult> {
-	const start = Date.now();
-	const dir = opts.conversationsDir || CONVERSATIONS_DIR;
-	const mode = opts.mode ?? "accept-edits";
-	const timeoutMin = opts.timeoutMin ?? DEFAULT_TIMEOUT_MIN;
-	const binary = resolveBinary(opts.binary);
-	const extra = [...extraArgsFromEnv(), ...(opts.extraArgs ?? [])];
-
-	const rawConvId = opts.conversationId ?? null;
-	const isContinuation =
-		typeof rawConvId === "string" && rawConvId.length > 0 && CONV_ID_RE.test(rawConvId);
-	const snapshot = isContinuation ? null : snapshotConversations(dir);
-	let lastIdx = opts.baseStepIdx ?? -1;
-
-	// Build argv. --add-dir first so agy binds the workspace before anything.
-	const args = ["--add-dir", opts.cwd, ...extra];
-	// When the MCP tool bridge is running, add its config dir so this agy
-	// discovers pi's tools (memory, codegraph, search, ...). agy reads
-	// .agents/mcp_config.json from --add-dir dirs. AskAntigravity does NOT pass
-	// this dir, so its agy stays plain (no recursion).
-	if (bridgeMcpConfigExists()) args.push("--add-dir", bridgeMcpConfigDir());
-	if (opts.model) args.push("--model", opts.model);
-	if (opts.effort) args.push("--effort", opts.effort);
-	args.push("--mode", mode);
-	// Without this, any run_command triggers an interactive permission prompt
-	// that hangs forever in non-interactive print mode (no TTY to answer y/n).
-	// accept-edits only auto-approves file writes, NOT commands. See PLAN.md.
-	if (opts.skipPermissions !== false) args.push("--dangerously-skip-permissions");
-	if (isContinuation && rawConvId) args.push("--conversation", rawConvId);
-	args.push("--print-timeout", `${timeoutMin}m`);
-	args.push("-p", opts.prompt);
-
-	let stderr = "";
-	let boundId = isContinuation ? rawConvId : null;
-	// Counts bind attempts so the /proc FD scan can't run on every tick forever
-	// when the snapshot stays ambiguous (see MAX_BIND_ATTEMPTS).
-	let bindAttempts = 0;
-
-	// One poller per turn, lazily opened once we know the conversation id.
-	let poller: ConversationPoller | null = null;
-	// agy extends the step it is currently writing in place (same idx, growing
-	// text). poll() returns only idx > lastIdx, so we re-read the last
-	// text/thinking step each tick and emit the grown suffix as a delta.
-	// flushStreamStep also runs BEFORE the loop so a step boundary landing
-	// inside this tick doesn't drop the outgoing step's final in-place tail
-	// (the loop may switch streamIdx to a new idx before we'd re-read).
-	let streamIdx = -1;
-	let streamKind: "text" | "thinking" | null = null;
-	let streamEmitted = 0;
-	const flushStreamStep = (): void => {
-		if (streamIdx < 0 || !poller || !streamKind) return;
-		const s = poller.readStepAt(streamIdx);
-		if (!s) return;
-		try {
-			const t = extractAgentText(s.payload);
-			if (t && t.text.length > streamEmitted) {
-				onEvent({ kind: streamKind, text: t.text.slice(streamEmitted) });
-				streamEmitted = t.text.length;
-			}
-		} catch {
-			/* torn re-read; next poll retries */
-		}
-	};
-	const pollOnce = (): boolean => {
-		// Bind the conversation id on a fresh run (agy doesn't print it).
-		// pid lets newConversationId disambiguate when a concurrent agy also
-		// drops a new .db in the dir during our turn (see discovery.ts).
-		if (!boundId && snapshot && bindAttempts < MAX_BIND_ATTEMPTS) {
-			boundId = newConversationId(dir, snapshot, {
-				pid: proc?.pid,
-				// Only the genuinely-ambiguous case (>1 new DB, unresolved) counts
-				// against the cap. The ordinary "agy hasn't written its DB yet" wait
-				// must keep polling for the full turn timeout, not burn a budget
-				// meant to bound the expensive /proc FD-scan retries.
-				onAmbiguous: () => { bindAttempts++; },
-			});
-		}
-		if (!boundId) return false;
-
-		if (!poller) {
-			poller = new ConversationPoller(conversationDbPath(boundId, dir), lastIdx);
-		}
-		if (!poller.isOpen && !poller.tryOpen()) return false;
-
-		// Coalesce: one data_version check per tick gates BOTH the in-place
-		// re-read (flushStreamStep -> readStepAt) and the new-row read. While
-		// agy is thinking and hasn't committed, hasChanged() is false and we
-		// skip both SELECTs, so no row read fires on an idle tick.
-		if (!poller.hasChanged()) return false;
-
-		// Catch the currently-tracked step's final in-place growth BEFORE the
-		// loop may switch tracking to a new step.
-		flushStreamStep();
-		const steps = poller.readNewSteps();
-		for (const step of steps) {
-			// A torn read (agy mid-write) can throw RangeError out of the protobuf
-			// walker. Drop that step rather than aborting the whole turn  -  the
-			// row settles on the next poll. (agy-acp database.ts pattern, lifted
-			// to the decode layer where the throw actually originates.)
-			try {
-				const event = decodeStep(step);
-				if (event) {
-					onEvent(event);
-					if (event.kind === "text" || event.kind === "thinking") {
-						streamIdx = step.idx;
-						streamKind = event.kind;
-						streamEmitted = event.text.length;
-					}
-				}
-			} catch {
-				/* drop undecodable step; lastIdx still advances past it */
-			}
-		}
-		flushStreamStep();
-		lastIdx = poller.lastIdx;
-		return steps.length > 0;
-	};
-
-	const result: AgyRunResult = {
-		exitCode: 0,
-		conversationId: null,
-		lastIdx: -1,
-		aborted: false,
-		timedOut: false,
-		stderr: "",
-		durationMs: 0,
-	};
-
-	let proc: ChildProcess | null = null;
-	let settled = false;
-	let timedOut = false;
-	let sigkillTimer: ReturnType<typeof setTimeout> | undefined;
-	let watchdog: ReturnType<typeof setTimeout> | undefined;
-
-	const killTree = () => {
-		try {
-			if (proc?.pid) process.kill(-proc.pid, "SIGTERM");
-		} catch {
-			/* process group already gone */
-		}
-		if (!sigkillTimer) {
-			sigkillTimer = setTimeout(() => {
-				try {
-					if (proc?.pid) process.kill(-proc.pid, "SIGKILL");
-				} catch {
-					/* give up */
-				}
-			}, GRACE_AFTER_TIMEOUT_MS);
-		}
-	};
-
-	const onAbort = () => killTree();
-
-	try {
-		await new Promise<void>((resolveP, rejectP) => {
-			// detached: true so we can signal the whole process group. agy
-			// spawns its own exec subprocesses in -p mode; a direct kill would
-			// orphan those grandchildren.
-			proc = spawn(binary, args, {
-				cwd: opts.cwd,
-				stdio: ["ignore", "ignore", "pipe"],
-				shell: false,
-				detached: true,
-			});
-			proc.stderr?.setEncoding("utf8");
-			proc.stderr?.on("data", (d: string) => (stderr += d));
-
-			// Drive the DB poll concurrently with the running process. THIS is the
-			// streaming: without it, no event reaches the caller until agy exits,
-			// defeating the whole point of the provider. Cleared in cleanup().
-			const pollTimer = setInterval(pollOnce, POLL_INTERVAL_MS);
-			pollTimer.unref?.();
-
-			const cleanup = () => {
-				clearInterval(pollTimer);
-				if (watchdog) clearTimeout(watchdog);
-				if (sigkillTimer) clearTimeout(sigkillTimer);
-				if (opts.signal) opts.signal.removeEventListener("abort", onAbort);
-			};
-
-			// Enforce the timeout ourselves (agy's --print-timeout is advisory).
-			watchdog = setTimeout(() => {
-				timedOut = true;
-				killTree();
-			}, timeoutMin * 60_000);
-
-			if (opts.signal) {
-				if (opts.signal.aborted) killTree();
-				else opts.signal.addEventListener("abort", onAbort, { once: true });
-			}
-
-			const finish = (code: number | null) => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				resolveP();
-				void code; // exit code read off proc below
-			};
-
-			proc.on("error", (err) => {
-				cleanup();
-				rejectP(err);
-			});
-			proc.on("close", finish);
-			proc.on("exit", finish);
-		});
-	} catch (err) {
-		// spawn ENOENT etc.  -  surface as a non-zero result, don't throw.
-		stderr += err instanceof Error ? err.message : String(err);
-	}
-
-	// Capture abort state before the trailing-poll loop. On cancel we skip the
-	// trailing polls (3 x 100ms) so the stream finalizes promptly with whatever
-	// was already streamed, instead of stalling ~300ms after agy was killed.
-	const wasAborted = !!opts.signal?.aborted;
-
-	// Trailing polls: agy may flush a final step moments after exit. The
-	// agy-acp pattern (3 x 100ms) catches these without adding noticeable latency.
-	if (!wasAborted) {
-		for (let i = 0; i < TRAILING_POLLS; i++) {
-			pollOnce();
-			await sleep(TRAILING_POLL_MS);
-		}
-	}
-
-	// CFA note: poller/proc are assigned inside closures that TS can't track
-	// through the await, so they narrow to `null` here. Casts break the
-	// narrowing without lying about the runtime type.
-	(poller as ConversationPoller | null)?.close();
-
-	result.exitCode = (proc as ChildProcess | null)?.exitCode ?? (stderr ? 1 : 0);
-	result.aborted = wasAborted;
-	result.timedOut = timedOut;
-	result.conversationId = boundId;
-	result.lastIdx = lastIdx;
-	result.stderr = stderr;
-	result.durationMs = Date.now() - start;
-	return result;
-}