better-supabase 0.14.0 → 0.15.0

package/dist/jwks-cache-CRymV-Dr.js

@@ -1,49 +0,0 @@
-import { n as dbError } from "./errors-03ysrOt4.js";
-import { a as ok, r as err } from "./result-B3m7xtRY.js";
-import { a as jwksOf } from "./jws-DOgHJKHb.js";
-//#region src/core/jwks-cache.ts
-/** The most bytes read from a JWKS response. */
-const MAX_JWKS_BYTES = 262144;
-/**
-* A cached key set. A URL is fetched on first use and again after
-* `cacheSeconds`; a refresh for an unknown `kid` refetches at most once per
-* `refetchSeconds`, so a stream of forged `kid`s can't hammer the issuer.
-* Concurrent callers share one fetch.
-*/
-function jwksSource(input, options = {}) {
-	const parse = (value) => jwksOf(value, options.rsa === void 0 ? {} : { rsa: options.rsa });
-	if (!(input instanceof URL) && typeof input !== "function") {
-		const keys = parse(input);
-		return () => Promise.resolve(ok(keys));
-	}
-	const now = options.now ?? Date.now;
-	const cacheMs = (options.cacheSeconds ?? 300) * 1e3;
-	const refetchMs = (options.refetchSeconds ?? 30) * 1e3;
-	let cached;
-	let pending;
-	const load = async () => {
-		if (typeof input === "function") return ok(parse(await input()));
-		const response = await (options.fetch ?? fetch)(input, { headers: { accept: "application/jwk-set+json, application/json" } });
-		if (!response.ok) return err(dbError("network", `The JWKS answered ${response.status}`, { code: "JWKS_FETCH_FAILED" }));
-		const text = await response.text();
-		if (text.length > MAX_JWKS_BYTES) return err(dbError("network", "The JWKS response is too large", { code: "JWKS_FETCH_FAILED" }));
-		return ok(parse(JSON.parse(text)));
-	};
-	return async (refresh) => {
-		const age = cached ? now() - cached.at : Number.POSITIVE_INFINITY;
-		if (cached && age < (refresh ? refetchMs : cacheMs)) return ok(cached.keys);
-		pending ??= load().catch((cause) => err(dbError("network", `The JWKS could not be loaded: ${cause instanceof Error ? cause.message : String(cause)}`, { code: "JWKS_FETCH_FAILED" }))).then((result) => {
-			if (result.ok) cached = {
-				keys: result.data,
-				at: now()
-			};
-			return result;
-		}).finally(() => {
-			pending = void 0;
-		});
-		const result = await pending;
-		return !result.ok && cached ? ok(cached.keys) : result;
-	};
-}
-//#endregion
-export { jwksSource as t };

package/dist/kit-Ct4Z6GIO.js

@@ -1,127 +0,0 @@
-import { n as dbError } from "./errors-03ysrOt4.js";
-import { n as validate } from "./standard-DtkpFGkS.js";
-import { n as claimAt } from "./claims-Bp9My7XP.js";
-import { t as authContext } from "./context-CYquqpA6.js";
-import { n as toSession } from "./view-BtgqxQLM.js";
-import { o as settle, r as guard } from "./respond-z_yfyitp.js";
-import { n as checkPermission } from "./authorizer-DPTeL-7h.js";
-//#region src/server/kit.ts
-/** `FormData` as a plain object; repeated keys become arrays. */
-function formDataObject(form) {
-	const out = {};
-	for (const key of new Set(form.keys())) {
-		const values = form.getAll(key);
-		out[key] = values.length > 1 ? values : values[0];
-	}
-	return out;
-}
-/** A failed `ActionResult`. */
-function actionError(error) {
-	return {
-		ok: false,
-		data: null,
-		error
-	};
-}
-/** What a `permission` on an action or route is checked against. */
-function callerResource(input) {
-	if (input === void 0 || input instanceof Request) return { type: "route" };
-	if (typeof input !== "object" || input === null || Array.isArray(input) || input instanceof FormData) return { type: "action" };
-	return {
-		type: "action",
-		properties: input
-	};
-}
-/**
-* Runs a `resource` loader; any failure refuses, so a missing row never reads
-* as granted.
-*/
-async function loadResource(load) {
-	const unavailable = dbError("forbidden", "The resource this needs could not be loaded", { code: "RESOURCE_UNAVAILABLE" });
-	let settled;
-	try {
-		settled = await settle(load);
-	} catch {
-		return unavailable;
-	}
-	if (!settled.ok) return settled.error;
-	const { data } = settled;
-	if (typeof data !== "object" || data === null || !("type" in data) || typeof data.type !== "string") return unavailable;
-	return data;
-}
-/**
-* `requireTenant`, `roles`, `permission` and `authorize`, in that order: the
-* session and tenant, or why the caller is refused.
-*/
-async function authorizeCaller(auth, checks, input, tenant, authorizer, scope) {
-	const session = toSession(auth);
-	if (checks.requireTenant && tenant === void 0) return dbError("forbidden", "Choose an organization first", { code: "NO_TENANT" });
-	if (checks.roles && !hasRole(auth, checks.roles, checks.roleClaim)) return dbError("forbidden", "You do not have the role this needs", { code: "MISSING_ROLE" });
-	if (checks.permission !== void 0) {
-		const resource = checks.resource ? await loadResource(() => checks.resource?.(input, {
-			...scope,
-			session,
-			tenant
-		})) : callerResource(input);
-		if ("kind" in resource) return resource;
-		const permitted = await checkPermission({
-			authorizer,
-			permission: checks.permission,
-			resource,
-			context: {
-				...authContext(auth),
-				...tenant === void 0 ? {} : { tenant }
-			}
-		});
-		if (!permitted.ok) return permitted.error;
-	}
-	if (checks.authorize && !await checks.authorize(session, input)) return dbError("forbidden", "You are not allowed to do this", { code: "NOT_AUTHORIZED" });
-	return {
-		session,
-		tenant
-	};
-}
-/** `guard`, then `authorizeCaller`: the caller, or the refusal. */
-async function requireCaller(auth, options, tenant, authorizer, scope) {
-	return guard(auth, options.allow, options.aal, options.scopes) ?? authorizeCaller(auth, options, void 0, tenant, authorizer, scope);
-}
-/**
-* Runs an action body with the guard, input validation and authorize checks
-* every adapter shares, and settles it into an `ActionResult`: `Result`s
-* unwrap, thrown `DbException`s become errors, other throws propagate (so
-* framework redirects keep working).
-*/
-async function runAction(auth, options, input, tenant, body, authorizer, scope) {
-	const denied = guard(auth, options.allow, options.aal, options.scopes);
-	if (denied) return actionError(denied);
-	let parsed = input instanceof FormData ? formDataObject(input) : input;
-	if (options.input) {
-		const checked = await validate(options.input, parsed, "input");
-		if (!checked.ok) return actionError(checked.error);
-		parsed = checked.data;
-	}
-	const caller = await authorizeCaller(auth, options, parsed, tenant, authorizer, scope);
-	if ("kind" in caller) return actionError(caller);
-	const settled = await settle(() => body(parsed, caller));
-	return settled.ok ? {
-		ok: true,
-		data: settled.data,
-		error: null
-	} : actionError(settled.error);
-}
-/** The strings at a dotted claim path: one string, or every string in an array. */
-function rolesAt(claims, path) {
-	const single = claimAt(claims, path);
-	if (single !== void 0) return [single];
-	let value = claims;
-	for (const segment of path.split(".")) value = typeof value === "object" && value !== null ? value[segment] : void 0;
-	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-/** Whether a signed-in caller holds one of `roles` at the claim `path`. */
-function hasRole(auth, roles, path = "app_metadata.role") {
-	if (auth.kind !== "user") return false;
-	const held = rolesAt(auth.claims, path);
-	return roles.some((role) => held.includes(role));
-}
-//#endregion
-export { rolesAt as a, requireCaller as i, formDataObject as n, runAction as o, hasRole as r, authorizeCaller as t };

package/dist/kit-DKfbNTAA.d.ts

@@ -1,94 +0,0 @@
-import { b as DbError } from "./result-C6jDfedy.js";
-import { r as AuthState } from "./resolve-CzUKTIMq.js";
-import { i as AuthorizationResource } from "./authorizer-DFP3gHv8.js";
-import { t as AuthSession } from "./view-2_I-2ukO.js";
-import { r as GuardOptions } from "./respond-CZYibxUx.js";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/server/kit.d.ts
-/**
- * What a server action returns: plain data, safe across any serialization
- * boundary.
- */
-type ActionResult<T> = {
-  readonly ok: true;
-  readonly data: T;
-  readonly error: null;
-} | {
-  readonly ok: false;
-  readonly data: null;
-  readonly error: DbError;
-};
-/**
- * Checks after `allow`, `aal` and `scopes`. A caller who fails one gets
- * `forbidden`: an `ActionResult` error, a 403, or the framework's refusal.
- */
-interface AuthorizeOptions<I, C, P, R extends boolean, Ref = unknown, X = ResourceLoaderContext<C, P>> {
-  /** Refuse callers without an active tenant, so `ctx.tenant` is a string. */
-  readonly requireTenant?: R;
-  /** Admit only users holding one of these roles at `roleClaim`. */
-  readonly roles?: readonly string[];
-  /**
-   * The dotted claim path `roles` reads: one string or an array. Defaults to
-   * `app_metadata.role`.
-   */
-  readonly roleClaim?: string;
-  /**
-   * The permission the server's `authorizer` must grant. Without an authorizer,
-   * or on any outcome but `granted`, the caller is refused; `approval-required`
-   * refuses with `code: "APPROVAL_REQUIRED"`.
-   */
-  readonly permission?: Ref;
-  /**
-   * The resource `permission` is checked against, loaded after the session and
-   * tenant checks, e.g. the project row with its owner and team. It gets the
-   * validated input and the request's context (`db`, `session`, `tenant`).
-   * Defaults to `{ type: "action" }` with the input as `properties`, or `{
-   * type: "route" }`. A thrown `DbException` refuses with its error (such as
-   * `not_found`); any other throw refuses with `forbidden` and `code:
-   * "RESOURCE_UNAVAILABLE"`.
-   */
-  readonly resource?: (input: I, ctx: X) => AuthorizationResource | Promise<AuthorizationResource>;
-  /**
-   * Return `false` to refuse the caller, e.g. `(session, input) =>
-   * input.ownerId === session.user.id`.
-   */
-  readonly authorize?: (session: AuthSession<C, P>, input: I) => boolean | Promise<boolean>;
-}
-/**
- * What a `resource` loader gets besides the input, when the adapter has no
- * context of its own.
- */
-interface ResourceLoaderContext<C = unknown, P = unknown> {
-  readonly session: AuthSession<C, P>;
-  readonly tenant: string | undefined;
-}
-/** What `requireTenant` and `authorize` add to the context. */
-interface AuthorizedContext<C, P, R extends boolean> {
-  readonly session: AuthSession<C, P>;
-  /**
-   * The active tenant: the action's `tenant`, then the server's `tenant`
-   * option, then the tenant claim (`tenantOf(session)`).
-   */
-  readonly tenant: R extends true ? string : string | undefined;
-}
-type ActionInput<S> = S extends StandardSchemaV1 ? StandardSchemaV1.InferInput<S> | FormData : unknown;
-type ActionParsed<S> = S extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<S> : unknown;
-type Unwrapped<T> = T extends {
-  readonly ok: true;
-  readonly data: infer D;
-} ? D : T extends {
-  readonly ok: false;
-} ? never : T;
-/** Guard, authorize and validate options of a framework-neutral action. */
-interface BlockActionOptions<S extends StandardSchemaV1 | undefined, C = unknown, P = unknown, R extends boolean = boolean, Ref = unknown, X = ResourceLoaderContext<C, P>> extends GuardOptions, AuthorizeOptions<ActionParsed<S>, C, P, R, Ref, X> {
-  /** Validates the input (plain object or `FormData`) with any Standard Schema. */
-  readonly input?: S;
-}
-/** The guard and authorize checks of a loader, page or route. */
-interface BlockRequireOptions<C = unknown, P = unknown, R extends boolean = boolean, Ref = unknown, X = ResourceLoaderContext<C, P>> extends GuardOptions, AuthorizeOptions<undefined, C, P, R, Ref, X> {}
-/** The strings at a dotted claim path: one string, or every string in an array. */
-declare function rolesAt(claims: Readonly<Record<string, unknown>> | undefined, path: string): readonly string[];
-/** Whether a signed-in caller holds one of `roles` at the claim `path`. */
-declare function hasRole(auth: AuthState, roles: readonly string[], path?: string): boolean;
-//#endregion
-export { AuthorizedContext as a, ResourceLoaderContext as c, rolesAt as d, AuthorizeOptions as i, Unwrapped as l, ActionParsed as n, BlockActionOptions as o, ActionResult as r, BlockRequireOptions as s, ActionInput as t, hasRole as u };

package/dist/knowledge-BKGrXdS_.js

@@ -1,272 +0,0 @@
-import { t as DbException } from "./db-exception-Lngc1W49.js";
-import { n as dbError } from "./errors-03ysrOt4.js";
-import { a as ok, r as err, t as AsyncResult } from "./result-B3m7xtRY.js";
-import { t as vectorLiteral } from "./search-Cn_DGluL.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { C as optionalText, D as recordOf, I as textOf, O as recordOrEmpty, f as errorText, h as instantOf, j as run, k as recordsOf, n as applyTemporal, o as blockCall, p as injectableOf } from "./block-helpers-CiKtrb6g.js";
-import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
-//#region src/blocks/knowledge/knowledge.ts
-const SCOPES = /* @__PURE__ */ new Set([
-	"organization",
-	"agent",
-	"project",
-	"chat",
-	"user"
-]);
-const STATUSES = /* @__PURE__ */ new Set([
-	"pending",
-	"ready",
-	"failed"
-]);
-const BREAKS = [
-	"\n\n",
-	"\n",
-	". ",
-	" "
-];
-const TEXT_TYPES = /^(text\/|application\/(json|xml|yaml|x-yaml|ld\+json|x-ndjson)\b)/;
-/**
-* Splits text into chunks of at most `size` characters, preferring a paragraph,
-* line, sentence or word break in the second half of each chunk, and repeating
-* `overlap` characters of the previous one.
-*/
-function chunk(text, options = {}) {
-	const size = options.size ?? 2e3;
-	const overlap = options.overlap ?? Math.min(200, Math.floor(size / 10));
-	if (!Number.isInteger(size) || size < 1) throw new RangeError("chunk size must be a positive whole number");
-	if (!Number.isInteger(overlap) || overlap < 0 || overlap >= size) throw new RangeError("chunk overlap must be at least 0 and below size");
-	const clean = text.replaceAll(/\r\n?/g, "\n").trim();
-	const chunks = [];
-	let start = 0;
-	while (start < clean.length) {
-		let end = Math.min(start + size, clean.length);
-		if (end < clean.length) {
-			const window = clean.slice(start, end);
-			for (const mark of BREAKS) {
-				const at = window.lastIndexOf(mark);
-				if (at >= window.length / 2) {
-					end = start + at + mark.length;
-					break;
-				}
-			}
-		}
-		const content = clean.slice(start, end).trim();
-		if (content !== "") chunks.push({
-			content,
-			tokens: Math.ceil(content.length / 4)
-		});
-		if (end >= clean.length) break;
-		const back = Math.max(end - overlap, start + 1);
-		const word = /\s/.test(clean.charAt(back - 1)) ? back - 1 : clean.indexOf(" ", back);
-		start = overlap > 0 && word >= back - 1 && word < end ? word + 1 : back;
-	}
-	return chunks;
-}
-/**
-* An `invalid_input` error unless the embedder returned `count` vectors of one
-* non-zero length with finite numbers.
-*/
-function checkVectors(vectors, count) {
-	const invalid = (message) => dbError("invalid_input", message, { hint: "EMBEDDING_INVALID" });
-	if (vectors.length !== count) return invalid(`The embedder returned ${vectors.length} vectors for ${count} values`);
-	const size = vectors[0]?.length ?? 0;
-	for (const vector of vectors) {
-		if (vector.length === 0 || vector.length !== size) return invalid("The embedder returned vectors of different or zero length");
-		if (!vector.every(Number.isFinite)) return invalid("The embedder returned a vector with a non-finite number");
-	}
-}
-const scopeOf = (value) => {
-	const text = textOf(value);
-	return SCOPES.has(text) ? text : "user";
-};
-const statusOf = (value) => {
-	const text = textOf(value);
-	return STATUSES.has(text) ? text : "failed";
-};
-function documentOf(value) {
-	const row = recordOf(value, "knowledge_documents");
-	return {
-		id: textOf(row["id"]),
-		organizationId: textOf(row["organization_id"]),
-		ownerId: textOf(row["owner_id"]),
-		scope: scopeOf(row["scope"]),
-		scopeId: optionalText(row["scope_id"]),
-		fileId: optionalText(row["file_id"]),
-		title: textOf(row["title"]),
-		source: optionalText(row["source"]),
-		metadata: recordOrEmpty(row["metadata"]),
-		status: statusOf(row["status"]),
-		error: optionalText(row["error"]),
-		chunkCount: Number(row["chunk_count"] ?? 0),
-		embeddingModel: optionalText(row["embedding_model"]),
-		createdAt: instantOf(row["created_at"]),
-		updatedAt: instantOf(row["updated_at"])
-	};
-}
-function hitOf(value) {
-	const row = recordOf(value, "knowledge_search");
-	return {
-		documentId: textOf(row["document_id"]),
-		index: Number(row["idx"]),
-		content: textOf(row["content"]),
-		metadata: recordOrEmpty(row["metadata"]),
-		title: textOf(row["title"]),
-		score: Number(row["score"])
-	};
-}
-const notFound = () => dbError("not_found", "No knowledge document you can see has this id", { hint: "KNOWLEDGE_NOT_FOUND" });
-const decoder = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
-function defaultExtract(file, data) {
-	if (!TEXT_TYPES.test(file.mediaType)) return Promise.reject(/* @__PURE__ */ new TypeError(`No text extractor for ${file.mediaType}; pass extract to createKnowledge`));
-	return Promise.resolve(decoder.decode(data));
-}
-const unsupported = (cause) => dbError("invalid_request", errorText(cause), { hint: "KNOWLEDGE_UNSUPPORTED" });
-/** Documents, chunks and hybrid search for retrieval. */
-function createKnowledge(options) {
-	applyTemporal(options);
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
-	const batchSize = options.batchSize ?? 64;
-	const extract = options.extract ?? defaultExtract;
-	const embedder = injectableOf("embedder", options.embedder);
-	const found = (value) => isRecord(value) ? AsyncResult.ok(documentOf(value)) : AsyncResult.err(notFound());
-	const create = (organizationId, document) => call("create_knowledge_document", {
-		tenant: organizationId,
-		title: document.title,
-		scope: document.scope,
-		scope_id: document.scopeId,
-		file_id: document.fileId,
-		source: document.source,
-		metadata: document.metadata,
-		owner: document.ownerId
-	}, documentOf);
-	const write = (documentId, chunks) => call("write_knowledge_chunks", {
-		document_id: documentId,
-		chunks: { items: chunks },
-		model: embedder?.model
-	}, (value) => value).andThen(found);
-	const fromText = (organizationId, document, text) => run(() => Promise.resolve(chunk(text, options.chunking))).andThen((chunks) => create(organizationId, document).andThen((created) => write(created.id, chunks)));
-	const embed = (values, signal) => embedder ? run(() => embedder.embed(values, signal === void 0 ? void 0 : { signal })) : AsyncResult.err(dbError("invalid_request", "createKnowledge has no embedder", { hint: "KNOWLEDGE_NO_EMBEDDER" }));
-	const process = (documentId, processOptions = {}) => AsyncResult.from(async () => {
-		let before = Number.POSITIVE_INFINITY;
-		for (;;) {
-			const pending = await service("pending_knowledge_chunks", {
-				document_id: documentId,
-				batch: batchSize
-			}, (value) => recordsOf(value, "pending_knowledge_chunks"));
-			if (!pending.ok) return pending;
-			if (pending.data.length === 0) return ok(0);
-			const vectors = await embed(pending.data.map((row) => textOf(row["content"])), processOptions.signal);
-			if (!vectors.ok) return vectors;
-			const invalid = checkVectors(vectors.data, pending.data.length);
-			if (invalid) return err(invalid);
-			const remaining = await service("set_knowledge_embeddings", {
-				document_id: documentId,
-				embeddings: { items: pending.data.map((row, index) => ({
-					idx: Number(row["idx"]),
-					hash: row["hash"],
-					embedding: vectorLiteral(vectors.data[index] ?? [])
-				})) },
-				model: embedder?.model
-			}, Number);
-			if (!remaining.ok || remaining.data === 0) return remaining;
-			if (processOptions.signal?.aborted) return ok(remaining.data);
-			if (remaining.data >= before) return ok(remaining.data);
-			before = remaining.data;
-		}
-	});
-	const client = {
-		documents: {
-			create,
-			get: (documentId) => call("get_knowledge_document", { document_id: documentId }, (value) => value).andThen(found),
-			list: (organizationId, listOptions = {}) => call("list_knowledge_documents", {
-				tenant: organizationId,
-				scope: listOptions.scope,
-				scope_id: listOptions.scopeId,
-				max_rows: listOptions.limit
-			}, (value) => recordsOf(value, "list_knowledge_documents").map(documentOf)),
-			write,
-			remove: (documentId) => call("delete_knowledge_document", { document_id: documentId }, (value) => value === true)
-		},
-		ingest: {
-			text: (organizationId, { text, ...document }) => fromText(organizationId, document, text),
-			file: (organizationId, fileId, document = {}) => {
-				const files = options.files;
-				if (!files) return AsyncResult.err(dbError("invalid_request", "createKnowledge has no files block", { hint: "KNOWLEDGE_NO_FILES" }));
-				return files.files.read(fileId).andThen(({ file, data }) => AsyncResult.from(async () => {
-					try {
-						return ok(await extract(file, data));
-					} catch (cause) {
-						return err(unsupported(cause));
-					}
-				}).andThen((text) => fromText(organizationId, {
-					...document,
-					title: document.title ?? file.filename,
-					fileId: file.id,
-					source: document.source ?? file.filename
-				}, text)));
-			}
-		},
-		process,
-		embedJob: () => async (payload, job, signal) => {
-			const result = await process(payload.document_id, { signal });
-			if (result.ok) return;
-			if (job.attempts >= job.maxAttempts) await service("fail_knowledge_document", {
-				document_id: payload.document_id,
-				error: result.error.message
-			}, (value) => value);
-			throw new DbException(result.error);
-		},
-		drain: (drainOptions = {}) => service("pending_knowledge_documents", { batch: drainOptions.batch }, (value) => Array.isArray(value) ? value.map(textOf) : []).andThen((ids) => AsyncResult.from(async () => {
-			const attempts = Math.max(1, drainOptions.attempts ?? 3);
-			let done = 0;
-			for (const id of ids) {
-				if (drainOptions.signal?.aborted) break;
-				let result = await process(id, drainOptions);
-				for (let attempt = 1; !result.ok && attempt < attempts && !drainOptions.signal?.aborted; attempt += 1) result = await process(id, drainOptions);
-				if (result.ok) done += 1;
-				else if (!drainOptions.signal?.aborted) await service("fail_knowledge_document", {
-					document_id: id,
-					error: result.error.message
-				}, (value) => value);
-			}
-			return ok(done);
-		})),
-		search: (organizationId, query, searchOptions = {}) => {
-			const { text, embedding } = typeof query === "string" ? {
-				text: query,
-				embedding: void 0
-			} : query;
-			return (embedding === void 0 && embedder !== void 0 && text !== void 0 && text !== "" ? embed([text], searchOptions.signal).map((vectors) => vectors[0]) : AsyncResult.ok(embedding)).andThen((value) => call("knowledge_search", {
-				tenant: organizationId,
-				query_embedding: value === void 0 ? void 0 : vectorLiteral(value),
-				query_text: text === "" ? void 0 : text,
-				scopes: searchOptions.scopes === void 0 ? void 0 : { items: searchOptions.scopes },
-				k: searchOptions.k,
-				filter: searchOptions.filter
-			}, (rows) => recordsOf(rows, "knowledge_search").map(hitOf)));
-		},
-		reembed: (reembedOptions = {}) => service("reembed_knowledge", {
-			tenant: reembedOptions.organizationId,
-			model: reembedOptions.model
-		}, Number)
-	};
-	const { documents, ingest, ...hooks } = options.hooks ?? {};
-	const logger = options.logger ? { logger: options.logger } : {};
-	return withBlockHooks({
-		...client,
-		documents: withBlockHooks(client.documents, documents, {
-			block: "knowledge.documents",
-			...logger
-		}),
-		ingest: withBlockHooks(client.ingest, ingest, {
-			block: "knowledge.ingest",
-			...logger
-		})
-	}, hooks, {
-		block: "knowledge",
-		...logger
-	});
-}
-//#endregion
-export { chunk as n, createKnowledge as r, checkVectors as t };