pi-roundtable 0.15.4 → 0.17.0

package/src/core/identity/identity-plugin.ts

@@ -1,3 +1,4 @@
+import { isCheckDatabase } from "../db/check-database.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
 import { IDENTITY, IDENTITY_LINKS } from "../services.ts";
 import type { AccessRules } from "./access-policy.ts";
@@ -45,12 +46,16 @@ export function identityPlugin(options: IdentityOptions): RoundtablePlugin {
 		provides: rules.selfLink ? [IDENTITY, IDENTITY_LINKS] : [IDENTITY],
 		setup: async ({ database, services, logger }) => {
 			if (summary) logger.info(backfillLine(summary));
+			const sql = database();
 			const identity = new PgIdentityService(
-				await PgPrincipalStore.attach(database()),
+				await PgPrincipalStore.attach(sql),
 				rules,
 				{ logger, identities },
 			);
-			await identity.syncConfig();
+			// `Roundtable.check()` has no database to write the configured principals to: it asks
+			// only what the configuration and the declared identities settle without one.
+			if (isCheckDatabase(sql)) identity.checkConfig();
+			else await identity.syncConfig();
 			services.provide(IDENTITY, identityView(identity));
 			if (rules.selfLink)
 				services.provide(

package/src/core/identity/identity-service.ts

@@ -15,10 +15,11 @@ import {
 	surfaceOf,
 } from "./actor-facts.ts";
 import { CachingPrincipalStore } from "./caching-principal-store.ts";
-import { configuredOwnerId } from "./config-owner.ts";
+import { configuredOwnerId, refuseOwnerDeclarations } from "./config-owner.ts";
 import type { Contact, ContactAssessor } from "./contact.ts";
 import {
 	type DeclaredIdentity,
+	refuseUnboundIdentities,
 	syncDeclaredIdentities,
 } from "./plugin-identities.ts";
 import { highest, lowest, publicOf, speakerOf } from "./principal-reads.ts";
@@ -141,6 +142,12 @@ export class PgIdentityService implements IdentityService, ContactAssessor {
 		this.#logger = options.logger;
 	}
 
+	/** The refusals `syncConfig` makes from the configuration and the declarations alone, for `Roundtable.check()`. */
+	checkConfig(): void {
+		refuseUnboundIdentities(this.#declared, this.#rules.owners.length > 0);
+		refuseOwnerDeclarations(this.#rules.owners, this.#declared);
+	}
+
 	/**
 	 * Makes the stored owners match the configuration: each configured owner's principal made or
 	 * renamed, their identities linked, and the owner role granted, all as the configuration's;

package/src/core/identity/plugin-identities.ts

@@ -57,6 +57,21 @@ export function declaredIdentities(
 	return declared;
 }
 
+/**
+ * The refusal `syncDeclaredIdentities` makes that needs no stored principal: an identity that names
+ * no principal when the configuration lists no primary owner to bind it to.
+ */
+export function refuseUnboundIdentities(
+	identities: readonly DeclaredIdentity[],
+	hasPrimaryOwner: boolean,
+): void {
+	for (const { plugin, identity, principal } of identities)
+		if (principal === undefined && !hasPrimaryOwner)
+			throw new ConfigError(
+				`plugin ${plugin}: ${identity} names no principal, and access.owners lists no primary owner to bind it to. Give the plugin the principal it stands for.`,
+			);
+}
+
 /**
  * Links each identity a plugin declares to its principal, `primaryOwner` by default, as the
  * plugin's: one the plugins bound to another principal at an earlier boot moves, one the
@@ -76,10 +91,10 @@ export async function syncDeclaredIdentities(
 		const ref = parseIdentity(identity);
 		if (!ref) throw new ConfigError(`plugin ${plugin}: ${identity}`);
 		const id = principal ?? primaryOwner;
-		if (id === undefined)
-			throw new ConfigError(
-				`plugin ${plugin}: ${identity} names no principal, and access.owners lists no primary owner to bind it to. Give the plugin the principal it stands for.`,
-			);
+		if (id === undefined) {
+			refuseUnboundIdentities([{ plugin, identity, principal }], false);
+			continue;
+		}
 		if (id === SYSTEM_PRINCIPAL || !(await store.get(id)))
 			throw new ConfigError(
 				`plugin ${plugin}: ${identity} is bound to principal ${id}, and there is no principal ${id}. roundtable principal list shows the principals, and roundtable principal create makes one.`,

package/src/core/modules/skills/skill-store.ts

@@ -1,4 +1,5 @@
 import type { SQL } from "bun";
+import { isCheckDatabase } from "../../db/check-database.ts";
 import { scopeToGuild } from "../../db/guild-scope.ts";
 import type { Migration } from "../../db/migrations.ts";
 import { AgentError } from "../../domain/errors.ts";
@@ -128,7 +129,8 @@ export class SkillStore {
 	/** The store over the host's migrated pool; the skills agents carry are those of one guild. */
 	static async attach(sql: SQL, guildId: string): Promise<SkillStore> {
 		const store = new SkillStore(sql, guildId);
-		await store.#reload();
+		// `Roundtable.check()` has no database to read the rows from: the store starts empty.
+		if (!isCheckDatabase(sql)) await store.#reload();
 		return store;
 	}
 

package/src/core/runtime/extensions/surface-formatting.ts

@@ -0,0 +1,22 @@
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Appends the formatting guidance of the surface the running turn replies on to the system
+ * prompt's appended part before each run, after the persona and what earlier handlers appended.
+ * Nothing is added when `guidance` returns undefined or only blank text: a turn whose channel has
+ * no surface, a surface without guidance, or no turn running.
+ */
+export function surfaceFormattingExtension(
+	guidance: () => string | undefined,
+): ExtensionFactory {
+	return (pi) => {
+		pi.on("before_agent_start", (event) => {
+			const text = guidance();
+			if (text === undefined || text.trim() === "") return;
+			const appended = event.systemPromptOptions.appendSystemPrompt;
+			event.systemPromptOptions.appendSystemPrompt = appended
+				? `${appended}\n\n${text}`
+				: text;
+		});
+	};
+}

package/src/core/runtime/pi-agent-runtime.ts

@@ -35,7 +35,7 @@ import { interimPoster } from "./interim-text.ts";
 import { preflightTools } from "./preflight-tools.ts";
 import { PromptSlot, workTimeout } from "./prompt-slot.ts";
 import { carriesMemory, recordMemoryTurn } from "./reader-history.ts";
-import type { RunningTurn } from "./running-turn.ts";
+import { type RunningTurn, runningTurn } from "./running-turn.ts";
 import type { PiAgentRuntimeOptions, TurnMessage } from "./runtime-types.ts";
 import { archiveSessions } from "./session-archive.ts";
 import {
@@ -86,6 +86,10 @@ export class PiAgentRuntime implements AgentRuntime {
 			speaker: (channel) => this.#turns.get(channel)?.speaker,
 			origin: (channel) => this.#turns.get(channel)?.origin,
 			client: (channel) => this.#turns.get(channel)?.client,
+			formatting: (channel) => {
+				const reply = this.#turns.get(channel)?.channel;
+				return reply === undefined ? undefined : options.formatting?.(reply);
+			},
 			withholdsMemory: (channel) => this.#turns.get(channel)?.withheld === true,
 			runTask: (scope, task) => this.#runTask(scope, task),
 		});
@@ -195,13 +199,7 @@ export class PiAgentRuntime implements AgentRuntime {
 				loadsMemory(registered),
 		);
 		this.#memoryTurns.set(key, markPrivateMemory);
-		this.#turns.set(key, {
-			tier,
-			speaker: request.speaker,
-			...(request.origin === undefined ? {} : { origin: request.origin }),
-			...(request.client === undefined ? {} : { client: request.client }),
-			withheld,
-		});
+		this.#turns.set(key, runningTurn(request, tier, withheld));
 		const missing = wanted.filter((name) => !registered.has(name));
 		if (missing.length > 0) {
 			logger.warn(

package/src/core/runtime/running-turn.ts

@@ -1,8 +1,11 @@
 import type { ClientPort } from "../domain/client.ts";
+import type { TurnRequest } from "../domain/ports.ts";
 import type { Speaker, Tier } from "../speakers.ts";
 
 /** What the runtime keeps about a conversation's running turn, for its tools to read. */
 export interface RunningTurn {
+	/** The channel the turn replies in, as `TurnRequest.channel` says; its surface formats the reply. */
+	channel: TurnRequest["channel"];
 	tier: Tier;
 	speaker: Speaker;
 	/** Where the turn's request came from, as `TurnRequest.origin` says. */
@@ -12,3 +15,19 @@ export interface RunningTurn {
 	/** Whether the turn loads no memory. */
 	withheld: boolean;
 }
+
+/** The record of a turn that starts: what its tools read while it runs. */
+export function runningTurn(
+	request: TurnRequest,
+	tier: Tier,
+	withheld: boolean,
+): RunningTurn {
+	return {
+		channel: request.channel,
+		tier,
+		speaker: request.speaker,
+		...(request.origin === undefined ? {} : { origin: request.origin }),
+		...(request.client === undefined ? {} : { client: request.client }),
+		withheld,
+	};
+}

package/src/core/runtime/runtime-plugin.ts

@@ -129,6 +129,8 @@ export function runtimePlugin(
 			const prompts = (channel: ChannelKey, scope?: PromptScope | Speaker) =>
 				context.surfaces.prompts(channel, scope);
 			const agents = () => options.agents?.current();
+			const formatting = (channel: ChannelKey) =>
+				context.surfaces.of(channel)?.formatting;
 			const running: AgentRuntime = providers.filled.has("runtime")
 				? providers.runtime(
 						runtimeDeps({
@@ -138,6 +140,7 @@ export function runtimePlugin(
 							sessions: context.sessions,
 							toolTiers: context.toolTiers,
 							prompts,
+							formatting,
 							agents,
 							confirmations: heldActions,
 							judge: providers.judge,
@@ -182,6 +185,7 @@ export function runtimePlugin(
 							return agents();
 						},
 						prompts,
+						formatting,
 						logger,
 						...(options.interimText
 							? { interimText: options.interimText }

package/src/core/runtime/runtime-types.ts

@@ -79,6 +79,13 @@ export interface PiAgentRuntimeOptions {
 	 * held action waits for a message that approves it.
 	 */
 	prompts?: (channel: ChannelKey, scope?: PromptScope) => Prompts | undefined;
+	/**
+	 * The formatting guidance of the chat surface that serves a channel, such as
+	 * `ChatSurface.formatting`; undefined for a channel with no surface or no guidance. Read before
+	 * each run for the channel the turn replies in, and appended to the system prompt after the
+	 * persona.
+	 */
+	formatting?: (channel: ChannelKey) => string | undefined;
 	/** The lowest tier that may use each tool; the default names the core's tools and leaves the rest to the owner. */
 	toolTiers?: ToolTiers;
 	/** A run that takes longer, not counting time spent waiting on the owner's cards, is aborted and reported as failed. */
@@ -124,13 +131,16 @@ export interface CoreExtensions {
 	askUser: ExtensionFactory;
 	selfCompactGuard: ExtensionFactory;
 	privateMemory: ExtensionFactory;
+	/** The formatting guidance of the surface the turn replies on, appended after the persona. */
+	surfaceFormatting: ExtensionFactory;
 	activeTools: ExtensionFactory;
 }
 
 /**
  * A session's extensions in load order: the tools phase, the core's attachment, gate, ask-user,
  * and compact guard, the compactor, the MCP phase, the memory projection, so each request is
- * projected after every other extension changed it, and active-tools last, so its
+ * projected after every other extension changed it, the surface's formatting guidance, so it follows
+ * the persona and everything appended before it, and active-tools last, so its
  * before_agent_start handler runs after every other extension's.
  */
 export function sessionExtensions(
@@ -160,6 +170,7 @@ export function sessionExtensions(
 		...contributed(plan.compaction ? [plan.compaction] : []),
 		...contributed(plan.mcp),
 		{ name: "private-memory", factory: core.privateMemory },
+		{ name: "surface-formatting", factory: core.surfaceFormatting },
 		{ name: "active-tools", factory: core.activeTools },
 	];
 }

package/src/core/runtime/session-factory.ts

@@ -58,6 +58,7 @@ import {
 	COMPACT_TOOL,
 	selfCompactGuardExtension,
 } from "./extensions/self-compact-guard.ts";
+import { surfaceFormattingExtension } from "./extensions/surface-formatting.ts";
 import type { PromptSlot } from "./prompt-slot.ts";
 import type {
 	ChannelSession,
@@ -85,6 +86,8 @@ export interface SessionFactoryDeps {
 	origin(channel: ChannelKey): string | undefined;
 	/** What the client that started the conversation's running turn can do for its tools. */
 	client(channel: ChannelKey): ClientPort | undefined;
+	/** The formatting guidance of the surface the conversation's running turn replies on. */
+	formatting(channel: ChannelKey): string | undefined;
 	/** Whether the conversation's running turn loads no memory, as the agent server's option keeps a speaker out of it. */
 	withholdsMemory(channel: ChannelKey): boolean;
 	/**
@@ -416,6 +419,10 @@ export class SessionFactory {
 							: memoryReader(conversation, deps.speaker(turnKey)),
 					state.draws,
 				),
+				surfaceFormatting: surfaceFormattingExtension(() =>
+					// A worker writes a report for the turn, not a reply on its surface.
+					worker ? undefined : deps.formatting(turnKey),
+				),
 				activeTools: activeToolsExtension(() => state.tools),
 			}),
 			// An agent's prompt is set before each run by the agent-prompt extension.

package/src/core/testing/database.ts

@@ -9,9 +9,27 @@ const url = process.env.ROUNDTABLE_TEST_DATABASE_URL;
 /** The guild the stores of the tests serve. */
 export const TEST_GUILD = "900000000000000001";
 
-export const testDatabaseUrl = url ?? "";
+/** The test database's URL, or "" when the run has none; `usePostgresForTests` sets it for the rest of the run. */
+export let testDatabaseUrl = url ?? "";
 
-export const describeDb = url ? describe : describe.skip;
+/** `describe` when the run has a test database, `describe.skip` otherwise; `usePostgresForTests` switches it on. */
+export let describeDb = url ? describe : describe.skip;
+
+/** Makes `url` the run's test database, for the tests and suites that read the two exports above afterwards. */
+export function adoptTestDatabase(url: string): void {
+	process.env.ROUNDTABLE_TEST_DATABASE_URL = url;
+	testDatabaseUrl = url;
+	describeDb = describe;
+}
+
+/** The test database's URL; throws, naming how to provide one, when the run has none. */
+export function requireDatabase(): string {
+	if (!testDatabaseUrl)
+		throw new Error(
+			"this test needs PostgreSQL: set ROUNDTABLE_TEST_DATABASE_URL to a throwaway database, or start one for the run with usePostgresForTests() in a test preload (it needs initdb and postgres on PATH or in PG_BIN)",
+		);
+	return testDatabaseUrl;
+}
 
 /** A test pool with the migrations run, as the host runs them before any store attaches; the caller closes it. */
 export async function migratedPool(...migrations: Migration[]): Promise<SQL> {

package/src/core/testing/postgres.ts

@@ -0,0 +1,160 @@
+import { afterAll } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SQL } from "bun";
+import { adoptTestDatabase } from "./database.ts";
+
+export interface UsePostgresOptions {
+	/** Directories searched for initdb and postgres before PATH; default PG_BIN and the usual Homebrew and Debian paths. */
+	binDirs?: readonly string[];
+	/** Throw when initdb or postgres is not found; default false (the tests that need it skip or call requireDatabase). */
+	require?: boolean;
+}
+
+/** Where a PostgreSQL install usually keeps initdb and postgres, newest first. */
+const USUAL_DIRS = [
+	...[17, 16, 15, 14].map(
+		(major) => `/opt/homebrew/opt/postgresql@${major}/bin`,
+	),
+	...[17, 16, 15, 14].map((major) => `/usr/lib/postgresql/${major}/bin`),
+	"/usr/local/bin",
+	"/usr/bin",
+];
+
+const READY_TIMEOUT_MS = 20_000;
+const STOP_TIMEOUT_MS = 10_000;
+
+function binary(name: string, dirs: readonly string[]): string | undefined {
+	for (const dir of dirs) {
+		const path = join(dir, name);
+		if (existsSync(path)) return path;
+	}
+	return Bun.which(name) ?? undefined;
+}
+
+/** A TCP port nothing listens on, found by binding port 0 and letting it go. */
+async function freePort(): Promise<number> {
+	const probe = Bun.serve({
+		port: 0,
+		hostname: "127.0.0.1",
+		fetch: () => new Response(),
+	});
+	const port = probe.port ?? 0;
+	await probe.stop(true);
+	return port;
+}
+
+/** Waits until the server at `url` answers a query, or throws when it exited or the wait ran out. */
+async function untilReady(url: string, server: Bun.Subprocess): Promise<void> {
+	const deadline = Date.now() + READY_TIMEOUT_MS;
+	for (;;) {
+		if (server.exitCode !== null)
+			throw new Error(
+				`the test PostgreSQL exited with code ${server.exitCode} before it was ready`,
+			);
+		const sql = new SQL(url, { max: 1 });
+		try {
+			await sql`SELECT 1`;
+			await sql.close();
+			return;
+		} catch {
+			await sql.close().catch(() => undefined);
+			if (Date.now() > deadline)
+				throw new Error(
+					`the test PostgreSQL did not become ready in ${READY_TIMEOUT_MS / 1000} seconds`,
+				);
+			await Bun.sleep(100);
+		}
+	}
+}
+
+/**
+ * For a test preload: unless ROUNDTABLE_TEST_DATABASE_URL is set, starts a throwaway PostgreSQL on
+ * 127.0.0.1 (trust auth, fsync off, a temporary data directory), sets the variable and
+ * `testDatabaseUrl`, and stops and removes it after the run (bun's global afterAll, exit and signals).
+ */
+export async function usePostgresForTests(
+	options: UsePostgresOptions = {},
+): Promise<void> {
+	const given = process.env.ROUNDTABLE_TEST_DATABASE_URL;
+	if (given) {
+		adoptTestDatabase(given);
+		return;
+	}
+	const dirs = options.binDirs ?? [process.env.PG_BIN ?? "", ...USUAL_DIRS];
+	const initdb = binary("initdb", dirs.filter(Boolean));
+	const postgres = binary("postgres", dirs.filter(Boolean));
+	if (!initdb || !postgres) {
+		if (options.require)
+			throw new Error(
+				"this run needs PostgreSQL: install it so initdb and postgres are on PATH, set PG_BIN to its bin directory, or set ROUNDTABLE_TEST_DATABASE_URL to a throwaway database",
+			);
+		return;
+	}
+	const root = mkdtempSync(join(tmpdir(), "roundtable-test-pg-"));
+	const data = join(root, "data");
+	const init = spawnSync(
+		initdb,
+		["-D", data, "-U", "postgres", "--auth=trust", "-E", "UTF8", "--no-sync"],
+		{ encoding: "utf8" },
+	);
+	if (init.status !== 0) {
+		rmSync(root, { recursive: true, force: true });
+		throw new Error(`initdb failed: ${init.stderr}`);
+	}
+	const port = await freePort();
+	const server = Bun.spawn(
+		[
+			postgres,
+			"-D",
+			data,
+			"-p",
+			String(port),
+			"-k",
+			root,
+			"-c",
+			"listen_addresses=127.0.0.1",
+			"-c",
+			"fsync=off",
+		],
+		{ stdout: "ignore", stderr: "ignore" },
+	);
+	let stopped = false;
+	const stop = async () => {
+		if (stopped) return;
+		stopped = true;
+		// SIGINT is PostgreSQL's fast shutdown: sessions end and the server exits at once.
+		server.kill("SIGINT");
+		await Promise.race([server.exited, Bun.sleep(STOP_TIMEOUT_MS)]);
+		rmSync(root, { recursive: true, force: true });
+	};
+	// A global hook of the run: bun runs preload hooks once, after every test file.
+	afterAll(stop);
+	process.on("exit", () => {
+		if (stopped) return;
+		server.kill("SIGINT");
+		// A process that exits without the run's hooks leaves no data directory behind. The server
+		// writes while it shuts down, so removing it takes a few tries.
+		for (let attempt = 0; attempt < 100 && existsSync(root); attempt++) {
+			try {
+				rmSync(root, { recursive: true, force: true });
+			} catch {
+				Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+			}
+		}
+	});
+	for (const signal of ["SIGINT", "SIGTERM"] as const)
+		process.on(signal, () => {
+			void stop().then(() => process.exit(1));
+		});
+	const url = `postgres://postgres@127.0.0.1:${port}/postgres`;
+	try {
+		await untilReady(url, server);
+	} catch (error) {
+		await stop();
+		throw error;
+	}
+	adoptTestDatabase(url);
+}

package/src/core/testing/run-tool.ts

@@ -0,0 +1,110 @@
+import type {
+	ExtensionAPI,
+	ExtensionFactory,
+} from "@earendil-works/pi-coding-agent";
+import type { ClientPart } from "../domain/client.ts";
+import type { ReplyFile } from "../domain/conversation.ts";
+import { PluginError } from "../errors.ts";
+import {
+	attachReplyFile,
+	hasReplyFileScope,
+	withReplyFiles,
+} from "../reply-files.ts";
+
+/** What a session registers of a tool: the call the model's tool call reaches. */
+export interface RegisteredTool {
+	name: string;
+	execute(
+		id: string,
+		params: Record<string, unknown>,
+		signal?: AbortSignal,
+	): Promise<{
+		content: readonly {
+			type: string;
+			text?: string;
+			data?: string;
+			mimeType?: string;
+		}[];
+		isError?: boolean;
+	}>;
+}
+
+/** What the model would get back from one tool call, and what the call attached beside the text. */
+export interface ToolCallResult {
+	text: string;
+	files: ReplyFile[];
+	images: ClientPart[];
+}
+
+/** Anything an extension may call or read on the Pi API besides registering a tool: accepted, does nothing. */
+type Ignored = (...args: readonly never[]) => Ignored;
+
+function ignored(): Ignored {
+	return new Proxy((() => ignored()) as Ignored, {
+		get: (target, key) => (key === "then" ? undefined : target),
+	});
+}
+
+/** The tools a factory registers, in order; every other registration (handlers, commands, events) is accepted and ignored. */
+export async function registeredTools(
+	factory: ExtensionFactory | null | undefined,
+): Promise<RegisteredTool[]> {
+	const tools: RegisteredTool[] = [];
+	if (!factory) return tools;
+	// SAFETY: a session factory only registers tools, handlers and commands; the fake records the tools and ignores the rest.
+	const api = new Proxy(
+		{},
+		{
+			get: (_target, key) =>
+				key === "registerTool"
+					? (definition: RegisteredTool) => tools.push(definition)
+					: ignored(),
+		},
+	) as unknown as ExtensionAPI;
+	await factory(api);
+	return tools;
+}
+
+/**
+ * Runs the call as a turn on a surface that takes files or not runs it: the text, the files it
+ * attached and the images it returned. A file is also queued for the enclosing real turn when a
+ * fake runtime runs the call inside one. A tool that throws throws here; a refusal (an `isError` result) comes back as its text.
+ */
+export async function callRegisteredTool(
+	tool: RegisteredTool,
+	args: Record<string, unknown>,
+	supportsFiles: boolean,
+): Promise<ToolCallResult> {
+	const images: ClientPart[] = [];
+	const result = await withReplyFiles(supportsFiles, async () => {
+		const output = await tool.execute("test-call", args);
+		for (const item of output.content)
+			if (item.type === "image" && item.data && item.mimeType)
+				images.push({
+					mimeType: item.mimeType,
+					data: new Uint8Array(Buffer.from(item.data, "base64")),
+				});
+		return {
+			ok: true,
+			text: output.content
+				.filter((item) => item.type === "text")
+				.map((item) => item.text ?? "")
+				.join("\n"),
+		};
+	});
+	if (!result.ok) throw result.error;
+	const files = result.files ?? [];
+	// When a tool is run by a fake runtime, forward into the enclosing real turn.
+	if (hasReplyFileScope()) for (const file of files) attachReplyFile(file);
+	return { text: result.text, files, images };
+}
+
+/** The registered tool called `name`, or the PluginError a test reads. */
+export function toolNamed(
+	tools: readonly RegisteredTool[],
+	name: string,
+): RegisteredTool {
+	const found = tools.find((tool) => tool.name === name);
+	if (!found) throw new PluginError(`tool ${name} is not registered`);
+	return found;
+}