@keystrokehq/platform 0.1.156 → 0.1.158

package/dist/{project-draft-notifier-DlWmyn5m.cjs → project-draft-notifier-BTrhFlJq.cjs}

@@ -5,6 +5,7 @@ let node_path = require("node:path");
 let node_os = require("node:os");
 let node_child_process = require("node:child_process");
 let _aws_sdk_client_s3 = require("@aws-sdk/client-s3");
+let _aws_sdk_s3_presigned_post = require("@aws-sdk/s3-presigned-post");
 let _aws_sdk_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
 //#region ../../packages/hosting/dist/runtime-BmfsHLrk.mjs
 /** Builds base64 `KEYSTROKE_ORG_ARTIFACTS` payload for org worker containers. */
@@ -356,7 +357,7 @@ function isCredentialInput(value) {
 }
 const credentialInputSchema = zod.z.custom((value) => isCredentialInput(value), "must be a credential requirement");
 //#endregion
-//#region ../../packages/shared/dist/billing-Ig0pw49a.mjs
+//#region ../../packages/shared/dist/billing-Bar2XMfx.mjs
 /**
 * Money is integer micro-credits (µc). 1 credit = $1 = 1,000,000 µc.
 * Shared so the web dashboard and the cloud billing packages agree on the
@@ -500,20 +501,25 @@ zod.z.object({
 const BillingUsageEventSourceSchema = zod.z.enum([
 	"ai_gateway",
 	"sandbox",
+	"browser",
 	"web_proxy",
 	"storage",
 	"dispatch",
-	"poll"
+	"poll",
+	"brain"
 ]);
 const BillingUsageMeterKeySchema = zod.z.enum([
 	"llm",
 	"vm_second",
+	"browser_second",
 	"web_search",
 	"web_fetch",
 	"workflow_run",
 	"agent_run",
 	"poll_trigger",
-	"tigris_storage"
+	"tigris_storage",
+	"brain_search",
+	"brain_indexing"
 ]);
 const BillingUsageKeySourceSchema = zod.z.enum(["platform", "byok"]);
 const BillingUsageRunKindSchema = zod.z.enum([
@@ -544,7 +550,7 @@ zod.z.object({
 	chargeMicroCredits: zod.z.number().int().nonnegative()
 });
 //#endregion
-//#region ../../packages/shared/dist/credential-runtime-Cbm2X9rK.mjs
+//#region ../../packages/shared/dist/credential-runtime-B1aMt2H1.mjs
 const ACTIVE_ORG_HEADER = "x-keystroke-org-id";
 function isValidIanaTimezone(value) {
 	try {
@@ -1177,6 +1183,16 @@ const ORGANIZATION_NAME_APOSTROPHE_PATTERN = /[''\u2018\u2019]/g;
 function normalizeOrganizationNameToSlugBase(name) {
 	return name.trim().toLowerCase().replace(ORGANIZATION_NAME_APOSTROPHE_PATTERN, "").replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
+const BrowserTabSchema = zod.z.object({
+	url: zod.z.string(),
+	title: zod.z.string().optional(),
+	active: zod.z.boolean()
+});
+const BrowserResumeStateSchema = zod.z.object({
+	tabs: zod.z.array(BrowserTabSchema),
+	lastScreenshotStorageKey: zod.z.string().optional(),
+	capturedAt: zod.z.string()
+});
 /** Same format as organization slugs — org-scoped, no global reserved list. */
 const ProjectSlugSchema = OrganizationSlugSchema;
 const PROJECT_SLUG_TAKEN_MESSAGE = "That slug is already taken.";
@@ -1329,6 +1345,619 @@ function jsonSchemaToZod(schema) {
 }
 /** Legacy flat catalog — kept during dual-write so runtime/storage stay unchanged. */
 const ROUTE_MANIFEST_REL_PATH = "dist/.keystroke/route-manifest.json";
+/** Lowercase dash-separated Brain slug (2–64 chars). */
+const BrainSlugSchema = zod.z.string().trim().toLowerCase().min(2, "Slug must be at least 2 characters").max(64, "Slug must be at most 64 characters").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use lowercase letters, numbers, and dashes only");
+/** Splits on the first `:` and validates each component as a Brain slug. */
+function parseBrainReference(value) {
+	const separatorIndex = value.indexOf(":");
+	if (separatorIndex === -1) {
+		const slug = BrainSlugSchema.safeParse(value);
+		return slug.success ? {
+			brainSlug: slug.data,
+			filterSlug: null
+		} : void 0;
+	}
+	const brain = BrainSlugSchema.safeParse(value.slice(0, separatorIndex));
+	const filter = BrainSlugSchema.safeParse(value.slice(separatorIndex + 1));
+	if (!brain.success || !filter.success) return;
+	return {
+		brainSlug: brain.data,
+		filterSlug: filter.data
+	};
+}
+/** Base Brain slug or qualified `{brain}:{filter}` reference. */
+const BrainReferenceSchema = zod.z.string().trim().toLowerCase().refine((value) => parseBrainReference(value) !== void 0, { message: "Expected a Brain slug or a {brain}:{filter} reference" });
+/**
+* Where a document's content originated (`linear`, `notion`, `slack`,
+* `manual`, or a customer-defined slug). Required on every upload and distinct
+* from trusted provisioner provenance (how the version entered the Brain).
+* Not a closed enum: known sources get branded presentation, unknown valid
+* sources remain supported.
+*/
+const BrainSourceSchema = zod.z.string().trim().toLowerCase().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "Use 1-64 lowercase letters, numbers, dashes, and underscores (starting alphanumeric)");
+/** Required, non-empty human description shown in list/detail views and agent tool catalogs. */
+const BrainDescriptionSchema = zod.z.string().trim().min(1).max(2e3);
+const BRAIN_MAX_FILE_BYTES = 100 * 1024 * 1024;
+const BRAIN_MAX_FOLDER_FILES = 1e3;
+const BRAIN_READ_MAX_CHARS = 2e4;
+/** Inline `content` / `blocks` put payload cap; larger content must use the file upload flow. */
+const BRAIN_MAX_INLINE_CONTENT_CHARS = 2e6;
+const BRAIN_MAX_BLOCKS_PER_DOCUMENT = 5e3;
+const BRAIN_MAX_BLOCK_CHARS = 4e4;
+const BRAIN_MAX_METADATA_STRING_CHARS = 1024;
+const BRAIN_CHUNK_DEFAULT_MAX_CHARACTERS = 8e3;
+const BRAIN_CHUNK_MAX_CHARACTERS = 4e4;
+zod.z.enum([
+	"doc",
+	"docx",
+	"docm",
+	"ppt",
+	"pps",
+	"pot",
+	"pptx",
+	"pptm",
+	"ppsx",
+	"ppsm",
+	"xls",
+	"xlsx",
+	"xlsm",
+	"xlsb",
+	"odt",
+	"ods",
+	"odp",
+	"rtf",
+	"epub",
+	"csv",
+	"pdf",
+	"txt",
+	"md",
+	"markdown",
+	"html",
+	"htm",
+	"json",
+	"xml",
+	"yaml",
+	"yml"
+]);
+zod.z.enum([
+	"doc",
+	"docx",
+	"ppt",
+	"pptx",
+	"xlsx",
+	"odt",
+	"ods",
+	"odp",
+	"rtf",
+	"epub",
+	"csv",
+	"pdf",
+	"txt",
+	"md",
+	"html",
+	"json",
+	"xml",
+	"yaml"
+]);
+const BrainStatusSchema = zod.z.enum([
+	"active",
+	"rebuilding",
+	"rebuild_failed",
+	"deleting"
+]);
+/** Brain resource membership roles. Owners additionally manage members and deletion. */
+const BrainMemberRoleSchema = zod.z.enum(["owner", "admin"]);
+/** `write` implies read. Grants authorize deployed project runtimes, not humans. */
+const BrainGrantAccessSchema = zod.z.enum(["read", "write"]);
+const BrainDocumentVersionStatusSchema = zod.z.enum([
+	"pending_upload",
+	"pending_ingest",
+	"queued",
+	"processing",
+	"ready",
+	"failed"
+]);
+const BrainDocumentFailureCodeSchema = zod.z.enum([
+	"format_mismatch",
+	"invalid_document",
+	"encrypted_document",
+	"unsupported_encoding",
+	"needs_ocr",
+	"no_extractable_text",
+	"extracted_content_too_large",
+	"too_many_chunks",
+	"parser_timeout",
+	"parser_resource_limit",
+	"parser_unavailable",
+	"embedding_failed",
+	"index_write_failed"
+]);
+const BrainSkippedReasonSchema = zod.z.enum([
+	"unsupported_extension",
+	"empty_file",
+	"file_too_large",
+	"duplicate_path",
+	"invalid_relative_path",
+	"hidden_path",
+	"operation_limit"
+]);
+const BrainDocumentWriteInputKindSchema = zod.z.enum([
+	"content",
+	"blocks",
+	"file"
+]);
+const BrainDocumentWriteOutcomeSchema = zod.z.enum([
+	"pending",
+	"ready",
+	"unchanged",
+	"failed"
+]);
+/**
+* Gateway embedding model id (`provider/model`). The catalog is discovered at
+* runtime from the Vercel AI Gateway, so this is a bounded shape check only;
+* existence and `type === 'embedding'` are validated server-side against a
+* cached catalog at Brain create/update.
+*/
+const BrainEmbeddingModelSchema = zod.z.string().trim().min(3).max(128).regex(/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/i, "Expected a provider/model embedding id");
+const BRAIN_EMBEDDING_MODEL_DEFAULT = "voyage/voyage-4";
+const BrainLanguageSchema = zod.z.enum([
+	"multilingual",
+	"arabic",
+	"danish",
+	"dutch",
+	"english",
+	"finnish",
+	"french",
+	"german",
+	"greek",
+	"hungarian",
+	"italian",
+	"norwegian",
+	"portuguese",
+	"romanian",
+	"russian",
+	"spanish",
+	"swedish",
+	"tamil",
+	"turkish"
+]);
+const BRAIN_LANGUAGE_DEFAULT = "english";
+/**
+* Character-exact chunk controls. An exact separator is preferred when
+* present; chunks still respect maxCharacters.
+*/
+const BrainCharacterChunkingSchema = zod.z.object({
+	maxCharacters: zod.z.number().int().min(1).max(BRAIN_CHUNK_MAX_CHARACTERS).default(BRAIN_CHUNK_DEFAULT_MAX_CHARACTERS),
+	overlapCharacters: zod.z.number().int().nonnegative().default(0),
+	separator: zod.z.string().min(1).optional()
+}).strict().refine((value) => value.overlapCharacters < value.maxCharacters, {
+	message: "overlapCharacters must be less than maxCharacters",
+	path: ["overlapCharacters"]
+});
+const BrainIndexConfigSchema = zod.z.object({
+	embeddingModel: BrainEmbeddingModelSchema.default(BRAIN_EMBEDDING_MODEL_DEFAULT),
+	chunking: BrainCharacterChunkingSchema.prefault({}),
+	language: BrainLanguageSchema.default(BRAIN_LANGUAGE_DEFAULT)
+}).strict();
+const BRAIN_RESERVED_ATTRIBUTE_NAMES = [
+	"id",
+	"documentId",
+	"brainId",
+	"versionId",
+	"revision",
+	"generation",
+	"chunkIndex",
+	"title",
+	"text",
+	"source",
+	"vector"
+];
+const BrainMetadataKeySchema = zod.z.string().regex(/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/, "Metadata keys must start with a letter and use letters, numbers, and underscores").refine((key) => !BRAIN_RESERVED_ATTRIBUTE_NAMES.includes(key) && !key.startsWith("titleFts") && !key.startsWith("textFts"), { message: "Metadata key collides with a reserved index attribute" });
+const BrainMetadataScalarSchema = zod.z.union([
+	zod.z.string().max(BRAIN_MAX_METADATA_STRING_CHARS),
+	zod.z.number().finite(),
+	zod.z.boolean()
+]);
+const BrainMetadataValueSchema = zod.z.union([BrainMetadataScalarSchema, zod.z.array(zod.z.string().max(BRAIN_MAX_METADATA_STRING_CHARS)).max(64)]);
+const BrainDocumentMetadataSchema = zod.z.record(BrainMetadataKeySchema, BrainMetadataValueSchema).refine((value) => Object.keys(value).length <= 32, { message: `At most 32 metadata keys are allowed` });
+/**
+* Flat filter over metadata attributes: scalar → equals, array → any-of
+* (In for scalar attributes, ContainsAny for array attributes). Entries AND
+* together.
+*/
+const BrainMetadataFilterSchema = zod.z.record(BrainMetadataKeySchema, zod.z.union([BrainMetadataScalarSchema, zod.z.array(BrainMetadataScalarSchema).min(1).max(64)])).refine((value) => Object.keys(value).length <= 32, { message: `At most 32 filter keys are allowed` });
+/**
+* Filter expression persisted by Brain filters and accepted as query-time
+* narrowing: an optional reserved `source` operand (scalar equals or any-of)
+* plus a flat metadata filter. Entries AND together. The stored document
+* `source` is always one scalar string; an array here only widens matching.
+*/
+const BrainFilterExpressionSchema = zod.z.object({
+	source: zod.z.union([BrainSourceSchema, zod.z.array(BrainSourceSchema).min(1).max(64)]).optional(),
+	metadata: BrainMetadataFilterSchema.optional()
+}).strict().refine((value) => value.source !== void 0 || value.metadata !== void 0 && Object.keys(value.metadata).length > 0, { message: "Filter requires a source or at least one metadata entry" });
+const BrainSummarySchema = zod.z.object({
+	id: zod.z.string().min(1),
+	slug: BrainSlugSchema,
+	name: zod.z.string().min(1),
+	description: BrainDescriptionSchema,
+	indexConfig: BrainIndexConfigSchema,
+	status: BrainStatusSchema,
+	/** Number of filters defined on this Brain (rendered as “Filtered views”). */
+	filterCount: zod.z.number().int().nonnegative(),
+	/** Requesting user's Brain membership role (management surfaces are membership-only). */
+	callerRole: BrainMemberRoleSchema,
+	createdAt: zod.z.string().datetime(),
+	updatedAt: zod.z.string().datetime()
+});
+BrainSummarySchema.extend({
+	createdByUserId: zod.z.string().min(1).nullable(),
+	documentCount: zod.z.number().int().nonnegative(),
+	readyDocumentCount: zod.z.number().int().nonnegative()
+});
+const BrainNameSchema = zod.z.string().trim().min(1).max(120);
+zod.z.object({
+	name: BrainNameSchema,
+	slug: BrainSlugSchema.optional(),
+	description: BrainDescriptionSchema,
+	indexConfig: BrainIndexConfigSchema.prefault({})
+}).strict();
+zod.z.object({
+	name: BrainNameSchema.optional(),
+	description: BrainDescriptionSchema.optional(),
+	indexConfig: BrainIndexConfigSchema.optional()
+}).strict().refine((value) => Object.values(value).some((field) => field !== void 0), { message: "At least one field is required" });
+zod.z.object({
+	brain: BrainSummarySchema,
+	/** Set when an indexConfig change kicked off a rebuild. */
+	rebuildStarted: zod.z.boolean()
+});
+zod.z.object({ brains: zod.z.array(BrainSummarySchema) });
+const BrainMemberSchema = zod.z.object({
+	userId: zod.z.string().min(1),
+	role: BrainMemberRoleSchema,
+	createdByUserId: zod.z.string().min(1).nullable(),
+	createdAt: zod.z.string().datetime(),
+	updatedAt: zod.z.string().datetime()
+});
+zod.z.object({
+	userId: zod.z.string().min(1),
+	role: BrainMemberRoleSchema.default("admin")
+}).strict();
+zod.z.object({ role: BrainMemberRoleSchema }).strict();
+zod.z.object({ members: zod.z.array(BrainMemberSchema) });
+const BrainGrantSchema = zod.z.object({
+	id: zod.z.string().min(1),
+	brainId: zod.z.string().min(1),
+	projectId: zod.z.string().min(1),
+	access: BrainGrantAccessSchema,
+	createdByUserId: zod.z.string().min(1).nullable(),
+	createdAt: zod.z.string().datetime()
+});
+zod.z.object({
+	projectId: zod.z.string().min(1),
+	access: BrainGrantAccessSchema.default("read")
+}).strict();
+zod.z.object({ grants: zod.z.array(BrainGrantSchema) });
+const BrainFilterSummarySchema = zod.z.object({
+	id: zod.z.string().min(1),
+	/** Local slug, unique per Brain and colon-free. */
+	slug: BrainSlugSchema,
+	/** `{brain-slug}:{filter-slug}` — the externally addressable reference. */
+	qualifiedSlug: BrainReferenceSchema,
+	name: zod.z.string().min(1),
+	description: BrainDescriptionSchema,
+	filter: BrainFilterExpressionSchema,
+	createdByUserId: zod.z.string().min(1).nullable(),
+	createdAt: zod.z.string().datetime(),
+	updatedAt: zod.z.string().datetime()
+});
+zod.z.object({
+	name: BrainNameSchema,
+	slug: BrainSlugSchema.optional(),
+	description: BrainDescriptionSchema,
+	filter: BrainFilterExpressionSchema
+}).strict();
+zod.z.object({
+	name: BrainNameSchema.optional(),
+	description: BrainDescriptionSchema.optional(),
+	filter: BrainFilterExpressionSchema.optional()
+}).strict().refine((value) => Object.values(value).some((field) => field !== void 0), { message: "At least one field is required" });
+zod.z.object({ filters: zod.z.array(BrainFilterSummarySchema) });
+const BrainDocumentIdSchema = zod.z.string().trim().min(1).max(512).refine((value) => ![...value].some((ch) => ch.charCodeAt(0) < 32 || ch.charCodeAt(0) === 127), { message: "documentId must not contain control characters" });
+const BrainDocumentTitleSchema = zod.z.string().trim().min(1).max(500);
+const BrainEmbeddingContextSchema = zod.z.string().trim().min(1).max(2e3);
+const BrainDocumentRevisionSchema = zod.z.string().trim().min(1).max(256);
+zod.z.string().trim().min(1).max(1024).refine((value) => ![...value].some((ch) => ch.charCodeAt(0) < 32 || ch.charCodeAt(0) === 127), { message: "file name must not contain control characters" });
+zod.z.string().trim().min(1).max(256);
+/** Authored semantic block: one caller-supplied block becomes one exact chunk. */
+const BrainDocumentBlockSchema = zod.z.object({
+	text: zod.z.string().min(1).max(BRAIN_MAX_BLOCK_CHARS),
+	heading: zod.z.string().trim().min(1).max(500).optional(),
+	meta: zod.z.record(zod.z.string().max(64), zod.z.string().max(BRAIN_MAX_METADATA_STRING_CHARS)).optional()
+}).strict();
+const sha256Hex$2 = zod.z.string().regex(/^[a-f0-9]{64}$/, "Expected a lowercase hex sha256 digest");
+zod.z.object({
+	documentId: BrainDocumentIdSchema,
+	title: BrainDocumentTitleSchema.optional(),
+	/** Where the content originated (`linear`, `notion`, `manual`, …). Required. */
+	source: BrainSourceSchema,
+	content: zod.z.string().min(1).max(BRAIN_MAX_INLINE_CONTENT_CHARS).optional(),
+	blocks: zod.z.array(BrainDocumentBlockSchema).min(1).max(BRAIN_MAX_BLOCKS_PER_DOCUMENT).optional(),
+	metadata: BrainDocumentMetadataSchema.optional(),
+	/** Extra text prefixed into chunk embeddings (like the title); never returned by read. */
+	embeddingContext: BrainEmbeddingContextSchema.optional(),
+	revision: BrainDocumentRevisionSchema.optional(),
+	chunking: BrainCharacterChunkingSchema.optional()
+}).strict().refine((value) => value.content !== void 0 !== (value.blocks !== void 0), { message: "Provide exactly one of content or blocks" }).refine((value) => value.blocks === void 0 || value.chunking === void 0, {
+	message: "Chunking controls are not allowed with blocks",
+	path: ["chunking"]
+});
+zod.z.object({
+	documentId: BrainDocumentIdSchema,
+	/** `queued` created a new version; `unchanged` skipped (revision or content hash matched). */
+	outcome: zod.z.enum(["queued", "unchanged"]),
+	versionId: zod.z.string().min(1).nullable(),
+	metadataUpdated: zod.z.boolean()
+});
+zod.z.object({ 
+/** Full replacement of the document's metadata attributes; never re-embeds. */
+metadata: BrainDocumentMetadataSchema }).strict();
+zod.z.object({ documentIds: zod.z.array(BrainDocumentIdSchema).min(1).max(100) }).strict();
+zod.z.object({ deletedDocumentIds: zod.z.array(BrainDocumentIdSchema) });
+const BrainProvisionerKindSchema = zod.z.enum(["workflow", "manual"]);
+/**
+* Trusted system provenance for how a version entered the Brain: a workflow
+* run (project-scoped) or a manual Brain-admin upload (organization-scoped,
+* user identity only). Distinct from document `source` (content origin).
+*/
+const BrainDocumentProvisionerSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("workflow"),
+	projectId: zod.z.string().min(1),
+	workflowRunId: zod.z.string().min(1),
+	workflowSlug: zod.z.string().min(1),
+	correlationId: zod.z.string().min(1)
+}).strict(), zod.z.object({
+	kind: zod.z.literal("manual"),
+	userId: zod.z.string().min(1)
+}).strict()]);
+const BrainDocumentWriteEventSchema = zod.z.object({
+	id: zod.z.string().min(1),
+	documentId: BrainDocumentIdSchema,
+	provisioner: BrainDocumentProvisionerSchema,
+	inputKind: BrainDocumentWriteInputKindSchema,
+	outcome: BrainDocumentWriteOutcomeSchema,
+	failureCode: zod.z.string().trim().min(1).max(128).nullable().optional(),
+	failureMessage: zod.z.string().trim().min(1).max(2e3).nullable().optional(),
+	submittedAt: zod.z.string().datetime(),
+	contentReceivedAt: zod.z.string().datetime().nullable().optional(),
+	completedAt: zod.z.string().datetime().nullable().optional()
+}).strict().superRefine((event, context) => {
+	const hasFailure = event.failureCode != null || event.failureMessage != null;
+	if (event.outcome === "pending") {
+		if (event.completedAt != null || hasFailure) context.addIssue({
+			code: "custom",
+			message: "Pending writes cannot have completion or failure fields"
+		});
+		return;
+	}
+	if (event.completedAt == null) context.addIssue({
+		code: "custom",
+		message: "Terminal writes require completedAt",
+		path: ["completedAt"]
+	});
+	if (event.outcome !== "failed" && hasFailure) context.addIssue({
+		code: "custom",
+		message: "Failure fields are only valid for failed writes"
+	});
+});
+/** List entry doubling as the ETL diffing primitive (compare sha256 / revision, then put). */
+const BrainDocumentSummarySchema = zod.z.object({
+	documentId: BrainDocumentIdSchema,
+	title: zod.z.string().min(1),
+	/** Where the current content originated (`linear`, `notion`, `manual`, …). */
+	source: BrainSourceSchema,
+	status: BrainDocumentVersionStatusSchema.nullable(),
+	/** Content hash of the live version; null until first ingest completes. */
+	sha256: zod.z.string().nullable(),
+	/** Caller-supplied revision fingerprint from the last put. */
+	revision: zod.z.string().nullable(),
+	failureCode: BrainDocumentFailureCodeSchema.nullable().optional(),
+	failureMessage: zod.z.string().nullable().optional(),
+	byteSize: zod.z.number().int().nonnegative().nullable().optional(),
+	chunkCount: zod.z.number().int().nonnegative().nullable().optional(),
+	/**
+	* Provenance for the event whose version is current. Null means legacy or
+	* unavailable provenance; later failed/unchanged writes never replace it.
+	*/
+	currentProvenance: BrainDocumentWriteEventSchema.nullable(),
+	createdAt: zod.z.string().datetime(),
+	updatedAt: zod.z.string().datetime()
+});
+BrainDocumentSummarySchema.extend({
+	metadata: BrainDocumentMetadataSchema.nullable(),
+	contentType: zod.z.string().nullable(),
+	format: zod.z.string().nullable()
+});
+/** Accepts one repeated query param or an array; normalizes to an array. */
+function queryList(schema) {
+	return zod.z.union([schema, zod.z.array(schema).min(1)]).transform((value) => Array.isArray(value) ? value : [value]).optional();
+}
+const ListBrainDocumentsQuerySchema = zod.z.object({
+	/** Filters documentIds by prefix (e.g. `slack:C123:`). */
+	prefix: zod.z.string().min(1).max(512).optional(),
+	/** Case-insensitive substring over title and documentId. */
+	search: zod.z.string().trim().min(1).max(256).optional(),
+	/** Any-of filter over document source. */
+	source: queryList(BrainSourceSchema),
+	/** Any-of filter over the current version's provisioner kind. */
+	provisionerKind: queryList(BrainProvisionerKindSchema),
+	/** Applies one persisted Brain filter expression (local filter slug). */
+	filterSlug: BrainSlugSchema.optional(),
+	cursor: zod.z.string().min(1).optional(),
+	limit: zod.z.coerce.number().int().min(1).max(500).default(100)
+});
+zod.z.object({
+	documents: zod.z.array(BrainDocumentSummarySchema),
+	nextCursor: zod.z.string().nullable()
+});
+zod.z.object({
+	documentId: BrainDocumentIdSchema,
+	cursor: zod.z.string().min(1).optional(),
+	limit: zod.z.coerce.number().int().min(1).max(100).default(50)
+});
+zod.z.object({
+	writes: zod.z.array(BrainDocumentWriteEventSchema),
+	nextCursor: zod.z.string().nullable()
+});
+const BrainUploadFileInputSchema = zod.z.object({
+	idempotencyId: zod.z.string().uuid(),
+	/** Doubles as the documentId; normalized as a relative path. */
+	documentId: BrainDocumentIdSchema,
+	size: zod.z.number().int().nonnegative().max(BRAIN_MAX_FILE_BYTES),
+	contentType: zod.z.string().min(1).max(255),
+	/** Local hash, verified by the worker and used for safe prepare-time dedupe. */
+	sha256: sha256Hex$2,
+	/** Where the content originated; manual UI uploads default to `manual`. */
+	source: BrainSourceSchema,
+	metadata: BrainDocumentMetadataSchema.optional()
+});
+zod.z.object({ files: zod.z.array(BrainUploadFileInputSchema).min(1).max(BRAIN_MAX_FOLDER_FILES) }).strict();
+const BrainUploadAcceptedSchema = zod.z.object({
+	idempotencyId: zod.z.string().uuid(),
+	documentId: BrainDocumentIdSchema,
+	versionId: zod.z.string().min(1),
+	/**
+	* Null when a verified content-addressed blob was reused and ingestion was
+	* queued immediately. Otherwise, submit the file as multipart form data.
+	*/
+	upload: zod.z.object({
+		method: zod.z.literal("POST"),
+		url: zod.z.string().url(),
+		fields: zod.z.record(zod.z.string(), zod.z.string())
+	}).nullable()
+});
+const BrainUploadSkippedSchema = zod.z.object({
+	documentId: BrainDocumentIdSchema,
+	reason: BrainSkippedReasonSchema,
+	message: zod.z.string().min(1).optional()
+});
+zod.z.object({
+	accepted: zod.z.array(BrainUploadAcceptedSchema),
+	skipped: zod.z.array(BrainUploadSkippedSchema)
+});
+zod.z.object({ versionIds: zod.z.array(zod.z.string().min(1)).min(1).max(100) }).strict();
+const FinalizeBrainUploadResultSchema = zod.z.object({
+	versionId: zod.z.string().min(1),
+	documentId: BrainDocumentIdSchema,
+	status: BrainDocumentVersionStatusSchema,
+	failureCode: BrainDocumentFailureCodeSchema.nullable().optional(),
+	failureMessage: zod.z.string().nullable().optional()
+});
+zod.z.object({ results: zod.z.array(FinalizeBrainUploadResultSchema) });
+/** `hybrid` = ANN + BM25 with server fusion; `semantic` / `keyword` drop one leg. */
+const BrainSearchModeSchema = zod.z.enum([
+	"hybrid",
+	"semantic",
+	"keyword"
+]);
+zod.z.object({
+	query: zod.z.string().trim().min(1).max(4e3),
+	mode: BrainSearchModeSchema.default("hybrid"),
+	limit: zod.z.number().int().min(1).max(20).default(5),
+	minScore: zod.z.number().min(0).max(1).optional(),
+	rerank: zod.z.boolean().default(true),
+	/** Query-time narrowing; ANDs with the persisted filter when a qualified reference is searched. */
+	filters: BrainFilterExpressionSchema.optional()
+}).strict();
+const BrainSearchHitSchema = zod.z.object({
+	/** Reference the hit was served through (qualified when searching a filter). */
+	brain: BrainReferenceSchema,
+	documentId: BrainDocumentIdSchema,
+	chunkId: zod.z.string().min(1),
+	score: zod.z.number(),
+	title: zod.z.string().min(1),
+	text: zod.z.string().min(1),
+	/** Where the document's content originated. */
+	source: BrainSourceSchema,
+	/** Human-readable location within the document (page/slide/heading) when known. */
+	locationLabel: zod.z.string().nullable(),
+	metadata: BrainDocumentMetadataSchema.nullable()
+});
+zod.z.object({
+	hits: zod.z.array(BrainSearchHitSchema),
+	reranked: zod.z.boolean()
+});
+zod.z.object({
+	query: zod.z.string().trim().min(1).max(4e3),
+	hits: zod.z.array(BrainSearchHitSchema).min(1).max(320),
+	limit: zod.z.number().int().min(1).max(20)
+}).strict();
+zod.z.object({
+	offset: zod.z.coerce.number().int().nonnegative().default(0),
+	maxChars: zod.z.coerce.number().int().min(1).max(BRAIN_READ_MAX_CHARS).default(BRAIN_READ_MAX_CHARS)
+});
+zod.z.object({
+	brain: BrainReferenceSchema,
+	documentId: BrainDocumentIdSchema,
+	title: zod.z.string().min(1),
+	offset: zod.z.number().int().nonnegative(),
+	text: zod.z.string(),
+	truncated: zod.z.boolean()
+});
+zod.z.object({
+	/** Reference the agent addresses (base slug or qualified `{brain}:{filter}`). */
+	slug: BrainReferenceSchema,
+	name: zod.z.string().min(1),
+	description: BrainDescriptionSchema,
+	/** Base Brain that owns the documents and index. */
+	brainSlug: BrainSlugSchema,
+	/** Filter slug when attached through a qualified reference; null otherwise. */
+	filterSlug: BrainSlugSchema.nullable(),
+	/** Persisted narrowing applied over the base Brain; null for base references. */
+	filter: BrainFilterExpressionSchema.nullable()
+});
+zod.z.object({
+	brainId: zod.z.string().min(1),
+	status: BrainStatusSchema,
+	/** Namespace generation the rebuild is writing into. */
+	targetGeneration: zod.z.number().int().positive()
+});
+const BrainOperationIdSchema = zod.z.string().regex(/^[a-f0-9]{64}$/);
+const BrainRuntimeJobCommonSchema = zod.z.object({
+	operationId: BrainOperationIdSchema,
+	/** Originating project for workflow-scoped jobs; null for organization-scoped
+	* operations (manual uploads, admin rebuilds/deletes). */
+	projectId: zod.z.string().min(1).nullable(),
+	brainId: zod.z.string().min(1),
+	brainSlug: BrainSlugSchema
+}).strict();
+zod.z.discriminatedUnion("operation", [
+	BrainRuntimeJobCommonSchema.extend({
+		operation: zod.z.literal("ingest-version"),
+		versionId: zod.z.string().min(1)
+	}),
+	BrainRuntimeJobCommonSchema.extend({ operation: zod.z.literal("rebuild-brain") }),
+	BrainRuntimeJobCommonSchema.extend({
+		operation: zod.z.literal("reconcile-metadata"),
+		documentId: BrainDocumentIdSchema
+	}),
+	BrainRuntimeJobCommonSchema.extend({
+		operation: zod.z.literal("cleanup-document"),
+		documentRowId: zod.z.string().min(1),
+		deletionEpoch: zod.z.number().int().positive(),
+		versionIds: zod.z.array(zod.z.string().min(1))
+	}),
+	BrainRuntimeJobCommonSchema.extend({
+		operation: zod.z.literal("cleanup-version"),
+		versionId: zod.z.string().min(1)
+	}),
+	BrainRuntimeJobCommonSchema.extend({
+		operation: zod.z.literal("cleanup-generation"),
+		generation: zod.z.number().int().positive()
+	}),
+	BrainRuntimeJobCommonSchema.extend({ operation: zod.z.literal("delete-brain") })
+]);
 const TriggerTypeSchema = zod.z.enum([
 	"webhook",
 	"poll",
@@ -1416,6 +2045,7 @@ const WorkflowCanvasNodeTypeSchema = zod.z.enum([
 zod.z.enum([
 	"workflow-step",
 	"agent",
+	"brain",
 	"llm",
 	"wait",
 	"hook",
@@ -1627,6 +2257,7 @@ const storedRouteManifestEntryV2Schema = zod.z.discriminatedUnion("kind", [
 		toolCount: zod.z.number().int().nonnegative(),
 		credentialCount: zod.z.number().int().nonnegative(),
 		sandboxMode: AgentSandboxModeSchema.optional(),
+		brainSlugs: zod.z.array(BrainReferenceSchema).default([]),
 		appSlugs: zod.z.array(zod.z.string()).default([]),
 		toolSlugs: zod.z.array(zod.z.string()).default([]),
 		/** Credential requirements per tool slug (the agent's credential consumer key). */
@@ -1777,6 +2408,7 @@ const AgentManifestShardSchema = zod.z.object({
 	toolCount: zod.z.number().int().nonnegative(),
 	credentialCount: zod.z.number().int().nonnegative(),
 	sandboxMode: AgentSandboxModeSchema.optional(),
+	brainSlugs: zod.z.array(BrainReferenceSchema).default([]),
 	appSlugs: zod.z.array(zod.z.string()).default([]),
 	toolSlugs: zod.z.array(zod.z.string()).default([]),
 	toolRequirements: zod.z.record(zod.z.string(), zod.z.array(CredentialRequirementSummarySchema)).optional(),
@@ -3171,6 +3803,20 @@ const SubmitMarketingContactRequestSchema = zod.z.object({
 	companyWebsite: zod.z.string().optional()
 });
 const SubmitMarketingContactResponseSchema = SubmitTeamRequestResponseSchema;
+/**
+* One embedding model from the AI Gateway catalog (`type === "embedding"`),
+* as served by `GET /api/embedding-models`. Any `id` here is a valid
+* `indexConfig.embeddingModel` for a Brain.
+*/
+const EmbeddingModelSchema = zod.z.object({
+	id: BrainEmbeddingModelSchema,
+	name: zod.z.string().min(1),
+	provider: zod.z.string().min(1),
+	contextWindow: zod.z.number().int().positive().optional(),
+	/** USD per 1M input tokens, when the catalog prices the model. */
+	inputPerMillionUsd: zod.z.number().nonnegative().optional()
+});
+zod.z.object({ models: zod.z.array(EmbeddingModelSchema) });
 const CredentialAccessUnavailableReasonSchema = zod.z.enum(["request_access", "reconnect_required"]);
 zod.z.object({
 	error: zod.z.literal("credential_access_unavailable"),
@@ -4772,7 +5418,7 @@ const ModuleBlobRefSchema = zod.z.object({
 });
 const isoDateTime = zod.z.string().datetime();
 /** Snapshot/content-addressed blob digests are always lowercase sha256. */
-const sha256Hex$2 = zod.z.string().regex(/^[a-f0-9]{64}$/, "Expected a lowercase hex sha256 digest");
+const sha256Hex$3 = zod.z.string().regex(/^[a-f0-9]{64}$/, "Expected a lowercase hex sha256 digest");
 /** Max bytes for a single source file collected or served from a deploy tree. */
 const PROJECT_SOURCE_MAX_FILE_BYTES = 256 * 1024;
 /** Max total bytes across all source files in a deploy tree listing. */
@@ -4851,17 +5497,17 @@ const ListProjectFilesResponseSchema = zod.z.object({
 zod.z.object({
 	path: zod.z.string().min(1),
 	contents: zod.z.string(),
-	hash: sha256Hex$2
+	hash: sha256Hex$3
 });
 /** A blob the CLI may need to upload, keyed by content hash. */
 const SourceBlobRefSchema = zod.z.object({
-	hash: sha256Hex$2,
+	hash: sha256Hex$3,
 	size: zod.z.number().int().nonnegative()
 });
 /** Request: ask the platform which blobs are missing and get presigned PUTs. */
 const PresignProjectSourceRequestSchema = zod.z.object({ blobs: zod.z.array(SourceBlobRefSchema) });
 const PresignedBlobUploadSchema = zod.z.object({
-	hash: sha256Hex$2,
+	hash: sha256Hex$3,
 	url: zod.z.string().url()
 });
 /** Response: presigned PUTs for the subset of blobs not already stored. */
@@ -4869,7 +5515,7 @@ const PresignProjectSourceResponseSchema = zod.z.object({ uploads: zod.z.array(P
 /** A file reference in a manifest upload: where the path's content lives. */
 const ManifestFileRefSchema = zod.z.object({
 	path: zod.z.string().min(1),
-	hash: sha256Hex$2
+	hash: sha256Hex$3
 });
 /** Request body the CLI sends to finalize a deploy's source manifest. */
 const UploadProjectSourceManifestRequestSchema = zod.z.object({ files: zod.z.array(ManifestFileRefSchema) });
@@ -4881,7 +5527,7 @@ const UploadProjectSourceResponseSchema = zod.z.object({
 const StoredManifestFileSchema = zod.z.object({
 	id: zod.z.string(),
 	path: zod.z.string().min(1),
-	hash: sha256Hex$2
+	hash: sha256Hex$3
 });
 /** The immutable per-deploy manifest persisted to object storage. */
 const StoredProjectSourceManifestSchema = zod.z.object({
@@ -6045,6 +6691,23 @@ function runTar(args, options = {}) {
 	});
 }
 //#endregion
+//#region ../../packages/storage/dist/collect-artifact-modules-CApdro3d.mjs
+/** Lowercase hex sha256 of raw bytes. */
+function sha256Hex(bytes) {
+	return (0, node_crypto.createHash)("sha256").update(bytes).digest("hex");
+}
+/**
+* Assert a content-addressed module blob matches its declared size and SHA-256 hash.
+* Returns a Buffer copy suitable for disk write / JSON parse.
+*/
+function assertModuleBlobMatchesHash(input) {
+	if (input.bytes.byteLength !== input.expectedSize) throw new Error(`Module blob size mismatch for ${input.path}: expected ${input.expectedSize}, got ${input.bytes.byteLength}`);
+	const actual = sha256Hex(input.bytes);
+	const expected = input.expectedHash.toLowerCase();
+	if (actual !== expected) throw new Error(`Module blob hash mismatch for ${input.path}: expected ${expected}, got ${actual}`);
+	return Buffer.from(input.bytes);
+}
+//#endregion
 //#region ../../packages/storage/dist/index.mjs
 function readEnv$1(env, ...keys) {
 	for (const key of keys) {
@@ -6132,6 +6795,19 @@ function projectSourceBlobKey(projectId, hash) {
 	return `projects/${projectId}/sources/blobs/${hash}`;
 }
 const AVATAR_EXTENSION = /^[a-z0-9]+$/;
+/** Agent-scoped Browser Use profile metadata. */
+function browserProfileMetaStorageKey(options) {
+	return `browser-media/${options.projectId}/${options.agentId}/profile.json`;
+}
+/** Session metadata JSON for live URL / recording pointers. */
+function browserSessionMetaStorageKey(options) {
+	return `browser-media/${options.projectId}/${options.agentId}/${options.sessionId}/meta.json`;
+}
+/** True when `key` is browser media owned by this project/agent/session. */
+function isBrowserMediaStorageKey(key, projectId, agentId, sessionId) {
+	const prefix = agentId && sessionId ? `browser-media/${projectId}/${agentId}/${sessionId}/` : agentId ? `browser-media/${projectId}/${agentId}/` : `browser-media/${projectId}/`;
+	return key.startsWith(prefix) && key.length > prefix.length;
+}
 /** Object key for a chat attachment in org-private storage. */
 function chatAttachmentStorageKey(projectId, id, ext) {
 	const normalizedExt = ext.replace(/^\./, "").toLowerCase();
@@ -6401,6 +7077,23 @@ function createStorage(config) {
 				ContentType: input.contentType ?? "application/gzip"
 			}), { expiresIn: input.expiresInSeconds ?? DEFAULT_PRESIGN_TTL_SECONDS });
 		},
+		async presignPost(input) {
+			return (0, _aws_sdk_s3_presigned_post.createPresignedPost)(client, {
+				Bucket: config.bucket,
+				Key: input.key,
+				Conditions: [[
+					"content-length-range",
+					input.contentLength,
+					input.contentLength
+				], [
+					"eq",
+					"$Content-Type",
+					input.contentType
+				]],
+				Fields: { "Content-Type": input.contentType },
+				Expires: input.expiresInSeconds ?? DEFAULT_PRESIGN_TTL_SECONDS
+			});
+		},
 		async deleteObject(key) {
 			await client.send(new _aws_sdk_client_s3.DeleteObjectCommand({
 				Bucket: config.bucket,
@@ -6482,21 +7175,6 @@ function extractRouteManifestFromArtifact(archive) {
 		});
 	}
 }
-/** Lowercase hex sha256 of raw bytes. */
-function sha256Hex(bytes) {
-	return (0, node_crypto.createHash)("sha256").update(bytes).digest("hex");
-}
-/**
-* Assert a content-addressed module blob matches its declared size and SHA-256 hash.
-* Returns a Buffer copy suitable for disk write / JSON parse.
-*/
-function assertModuleBlobMatchesHash(input) {
-	if (input.bytes.byteLength !== input.expectedSize) throw new Error(`Module blob size mismatch for ${input.path}: expected ${input.expectedSize}, got ${input.bytes.byteLength}`);
-	const actual = sha256Hex(input.bytes);
-	const expected = input.expectedHash.toLowerCase();
-	if (actual !== expected) throw new Error(`Module blob hash mismatch for ${input.path}: expected ${expected}, got ${actual}`);
-	return Buffer.from(input.bytes);
-}
 /** Parse index JSON bytes from object storage. */
 function parseProjectArtifactIndex(bytes) {
 	return ProjectArtifactIndexSchema.parse(JSON.parse(Buffer.from(bytes).toString("utf8")));
@@ -6559,6 +7237,47 @@ async function prefetchCanvasShards(access, workflowSlug) {
 	];
 	await access.prefetchKeystrokeJson(paths);
 }
+async function putBrowserProfileMeta(storage, options) {
+	const key = browserProfileMetaStorageKey(options);
+	const meta = {
+		cloudProfileId: options.cloudProfileId,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await storage.putObject({
+		key,
+		body: Buffer.from(JSON.stringify(meta, null, 2), "utf8"),
+		contentType: "application/json"
+	});
+	return key;
+}
+async function getBrowserProfileMeta(storage, options) {
+	try {
+		const bytes = await storage.getObject(browserProfileMetaStorageKey(options));
+		return JSON.parse(new TextDecoder().decode(bytes));
+	} catch {
+		return null;
+	}
+}
+/** Persist browser session metadata JSON on the org bucket. */
+async function putBrowserSessionMeta(storage, options) {
+	const key = browserSessionMetaStorageKey(options);
+	await storage.putObject({
+		key,
+		body: Buffer.from(JSON.stringify(options.meta, null, 2), "utf8"),
+		contentType: "application/json"
+	});
+	return key;
+}
+async function getBrowserSessionMeta(storage, options) {
+	const key = browserSessionMetaStorageKey(options);
+	try {
+		const bytes = await storage.getObject(key);
+		const text = new TextDecoder().decode(bytes);
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
 /** Shared bucket for cross-org public assets (avatars, org sidebar logos). */
 const KEYSTROKE_ASSETS_BUCKET = "keystroke-assets";
 /** Env var for the browser-facing origin of public asset objects (no trailing slash). */
@@ -6896,6 +7615,24 @@ Object.defineProperty(exports, "AppSlugAvailabilityResponseSchema", {
 		return AppSlugAvailabilityResponseSchema;
 	}
 });
+Object.defineProperty(exports, "BrainDocumentIdSchema", {
+	enumerable: true,
+	get: function() {
+		return BrainDocumentIdSchema;
+	}
+});
+Object.defineProperty(exports, "BrainReferenceSchema", {
+	enumerable: true,
+	get: function() {
+		return BrainReferenceSchema;
+	}
+});
+Object.defineProperty(exports, "BrowserResumeStateSchema", {
+	enumerable: true,
+	get: function() {
+		return BrowserResumeStateSchema;
+	}
+});
 Object.defineProperty(exports, "CancelManagedDeployRequestSchema", {
 	enumerable: true,
 	get: function() {
@@ -7274,6 +8011,12 @@ Object.defineProperty(exports, "ListAppsResponseSchema", {
 		return ListAppsResponseSchema;
 	}
 });
+Object.defineProperty(exports, "ListBrainDocumentsQuerySchema", {
+	enumerable: true,
+	get: function() {
+		return ListBrainDocumentsQuerySchema;
+	}
+});
 Object.defineProperty(exports, "ListChannelPlatformsResponseSchema", {
 	enumerable: true,
 	get: function() {
@@ -8144,6 +8887,18 @@ Object.defineProperty(exports, "formatStorageErrorDetail", {
 		return formatStorageErrorDetail;
 	}
 });
+Object.defineProperty(exports, "getBrowserProfileMeta", {
+	enumerable: true,
+	get: function() {
+		return getBrowserProfileMeta;
+	}
+});
+Object.defineProperty(exports, "getBrowserSessionMeta", {
+	enumerable: true,
+	get: function() {
+		return getBrowserSessionMeta;
+	}
+});
 Object.defineProperty(exports, "graphqlIntrospectionToAppTemplate", {
 	enumerable: true,
 	get: function() {
@@ -8168,6 +8923,12 @@ Object.defineProperty(exports, "isAppLogoStorageKey", {
 		return isAppLogoStorageKey;
 	}
 });
+Object.defineProperty(exports, "isBrowserMediaStorageKey", {
+	enumerable: true,
+	get: function() {
+		return isBrowserMediaStorageKey;
+	}
+});
 Object.defineProperty(exports, "isChatAttachmentStorageKey", {
 	enumerable: true,
 	get: function() {
@@ -8492,6 +9253,18 @@ Object.defineProperty(exports, "publishDraftUpdateBestEffort", {
 		return publishDraftUpdateBestEffort;
 	}
 });
+Object.defineProperty(exports, "putBrowserProfileMeta", {
+	enumerable: true,
+	get: function() {
+		return putBrowserProfileMeta;
+	}
+});
+Object.defineProperty(exports, "putBrowserSessionMeta", {
+	enumerable: true,
+	get: function() {
+		return putBrowserSessionMeta;
+	}
+});
 Object.defineProperty(exports, "requiredDisplayTextSchema", {
 	enumerable: true,
 	get: function() {
@@ -8619,4 +9392,4 @@ Object.defineProperty(exports, "waitForHealth", {
 	}
 });
 
-//# sourceMappingURL=project-draft-notifier-DlWmyn5m.cjs.map
+//# sourceMappingURL=project-draft-notifier-BTrhFlJq.cjs.map