@keystrokehq/platform 0.1.156 → 0.1.158

package/dist/{project-draft-notifier-B7K0aaAp.mjs → project-draft-notifier-DbGvx0CD.mjs}

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { CreateBucketCommand, DeleteBucketCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutBucketAclCommand, PutBucketPolicyCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { createPresignedPost } from "@aws-sdk/s3-presigned-post";
 import { getSignedUrl } from "@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 = 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 @@ z.object({
 const BillingUsageEventSourceSchema = z.enum([
 	"ai_gateway",
 	"sandbox",
+	"browser",
 	"web_proxy",
 	"storage",
 	"dispatch",
-	"poll"
+	"poll",
+	"brain"
 ]);
 const BillingUsageMeterKeySchema = 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 = z.enum(["platform", "byok"]);
 const BillingUsageRunKindSchema = z.enum([
@@ -544,7 +550,7 @@ z.object({
 	chargeMicroCredits: 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 = z.object({
+	url: z.string(),
+	title: z.string().optional(),
+	active: z.boolean()
+});
+const BrowserResumeStateSchema = z.object({
+	tabs: z.array(BrowserTabSchema),
+	lastScreenshotStorageKey: z.string().optional(),
+	capturedAt: 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 = 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 = 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 = 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 = 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;
+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"
+]);
+z.enum([
+	"doc",
+	"docx",
+	"ppt",
+	"pptx",
+	"xlsx",
+	"odt",
+	"ods",
+	"odp",
+	"rtf",
+	"epub",
+	"csv",
+	"pdf",
+	"txt",
+	"md",
+	"html",
+	"json",
+	"xml",
+	"yaml"
+]);
+const BrainStatusSchema = z.enum([
+	"active",
+	"rebuilding",
+	"rebuild_failed",
+	"deleting"
+]);
+/** Brain resource membership roles. Owners additionally manage members and deletion. */
+const BrainMemberRoleSchema = z.enum(["owner", "admin"]);
+/** `write` implies read. Grants authorize deployed project runtimes, not humans. */
+const BrainGrantAccessSchema = z.enum(["read", "write"]);
+const BrainDocumentVersionStatusSchema = z.enum([
+	"pending_upload",
+	"pending_ingest",
+	"queued",
+	"processing",
+	"ready",
+	"failed"
+]);
+const BrainDocumentFailureCodeSchema = 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 = z.enum([
+	"unsupported_extension",
+	"empty_file",
+	"file_too_large",
+	"duplicate_path",
+	"invalid_relative_path",
+	"hidden_path",
+	"operation_limit"
+]);
+const BrainDocumentWriteInputKindSchema = z.enum([
+	"content",
+	"blocks",
+	"file"
+]);
+const BrainDocumentWriteOutcomeSchema = 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 = 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 = 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 = z.object({
+	maxCharacters: z.number().int().min(1).max(BRAIN_CHUNK_MAX_CHARACTERS).default(BRAIN_CHUNK_DEFAULT_MAX_CHARACTERS),
+	overlapCharacters: z.number().int().nonnegative().default(0),
+	separator: z.string().min(1).optional()
+}).strict().refine((value) => value.overlapCharacters < value.maxCharacters, {
+	message: "overlapCharacters must be less than maxCharacters",
+	path: ["overlapCharacters"]
+});
+const BrainIndexConfigSchema = 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 = 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 = z.union([
+	z.string().max(BRAIN_MAX_METADATA_STRING_CHARS),
+	z.number().finite(),
+	z.boolean()
+]);
+const BrainMetadataValueSchema = z.union([BrainMetadataScalarSchema, z.array(z.string().max(BRAIN_MAX_METADATA_STRING_CHARS)).max(64)]);
+const BrainDocumentMetadataSchema = 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 = z.record(BrainMetadataKeySchema, z.union([BrainMetadataScalarSchema, 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 = z.object({
+	source: z.union([BrainSourceSchema, 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 = z.object({
+	id: z.string().min(1),
+	slug: BrainSlugSchema,
+	name: z.string().min(1),
+	description: BrainDescriptionSchema,
+	indexConfig: BrainIndexConfigSchema,
+	status: BrainStatusSchema,
+	/** Number of filters defined on this Brain (rendered as “Filtered views”). */
+	filterCount: z.number().int().nonnegative(),
+	/** Requesting user's Brain membership role (management surfaces are membership-only). */
+	callerRole: BrainMemberRoleSchema,
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime()
+});
+BrainSummarySchema.extend({
+	createdByUserId: z.string().min(1).nullable(),
+	documentCount: z.number().int().nonnegative(),
+	readyDocumentCount: z.number().int().nonnegative()
+});
+const BrainNameSchema = z.string().trim().min(1).max(120);
+z.object({
+	name: BrainNameSchema,
+	slug: BrainSlugSchema.optional(),
+	description: BrainDescriptionSchema,
+	indexConfig: BrainIndexConfigSchema.prefault({})
+}).strict();
+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" });
+z.object({
+	brain: BrainSummarySchema,
+	/** Set when an indexConfig change kicked off a rebuild. */
+	rebuildStarted: z.boolean()
+});
+z.object({ brains: z.array(BrainSummarySchema) });
+const BrainMemberSchema = z.object({
+	userId: z.string().min(1),
+	role: BrainMemberRoleSchema,
+	createdByUserId: z.string().min(1).nullable(),
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime()
+});
+z.object({
+	userId: z.string().min(1),
+	role: BrainMemberRoleSchema.default("admin")
+}).strict();
+z.object({ role: BrainMemberRoleSchema }).strict();
+z.object({ members: z.array(BrainMemberSchema) });
+const BrainGrantSchema = z.object({
+	id: z.string().min(1),
+	brainId: z.string().min(1),
+	projectId: z.string().min(1),
+	access: BrainGrantAccessSchema,
+	createdByUserId: z.string().min(1).nullable(),
+	createdAt: z.string().datetime()
+});
+z.object({
+	projectId: z.string().min(1),
+	access: BrainGrantAccessSchema.default("read")
+}).strict();
+z.object({ grants: z.array(BrainGrantSchema) });
+const BrainFilterSummarySchema = z.object({
+	id: 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: z.string().min(1),
+	description: BrainDescriptionSchema,
+	filter: BrainFilterExpressionSchema,
+	createdByUserId: z.string().min(1).nullable(),
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime()
+});
+z.object({
+	name: BrainNameSchema,
+	slug: BrainSlugSchema.optional(),
+	description: BrainDescriptionSchema,
+	filter: BrainFilterExpressionSchema
+}).strict();
+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" });
+z.object({ filters: z.array(BrainFilterSummarySchema) });
+const BrainDocumentIdSchema = 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 = z.string().trim().min(1).max(500);
+const BrainEmbeddingContextSchema = z.string().trim().min(1).max(2e3);
+const BrainDocumentRevisionSchema = z.string().trim().min(1).max(256);
+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" });
+z.string().trim().min(1).max(256);
+/** Authored semantic block: one caller-supplied block becomes one exact chunk. */
+const BrainDocumentBlockSchema = z.object({
+	text: z.string().min(1).max(BRAIN_MAX_BLOCK_CHARS),
+	heading: z.string().trim().min(1).max(500).optional(),
+	meta: z.record(z.string().max(64), z.string().max(BRAIN_MAX_METADATA_STRING_CHARS)).optional()
+}).strict();
+const sha256Hex$2 = z.string().regex(/^[a-f0-9]{64}$/, "Expected a lowercase hex sha256 digest");
+z.object({
+	documentId: BrainDocumentIdSchema,
+	title: BrainDocumentTitleSchema.optional(),
+	/** Where the content originated (`linear`, `notion`, `manual`, …). Required. */
+	source: BrainSourceSchema,
+	content: z.string().min(1).max(BRAIN_MAX_INLINE_CONTENT_CHARS).optional(),
+	blocks: 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"]
+});
+z.object({
+	documentId: BrainDocumentIdSchema,
+	/** `queued` created a new version; `unchanged` skipped (revision or content hash matched). */
+	outcome: z.enum(["queued", "unchanged"]),
+	versionId: z.string().min(1).nullable(),
+	metadataUpdated: z.boolean()
+});
+z.object({ 
+/** Full replacement of the document's metadata attributes; never re-embeds. */
+metadata: BrainDocumentMetadataSchema }).strict();
+z.object({ documentIds: z.array(BrainDocumentIdSchema).min(1).max(100) }).strict();
+z.object({ deletedDocumentIds: z.array(BrainDocumentIdSchema) });
+const BrainProvisionerKindSchema = 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 = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("workflow"),
+	projectId: z.string().min(1),
+	workflowRunId: z.string().min(1),
+	workflowSlug: z.string().min(1),
+	correlationId: z.string().min(1)
+}).strict(), z.object({
+	kind: z.literal("manual"),
+	userId: z.string().min(1)
+}).strict()]);
+const BrainDocumentWriteEventSchema = z.object({
+	id: z.string().min(1),
+	documentId: BrainDocumentIdSchema,
+	provisioner: BrainDocumentProvisionerSchema,
+	inputKind: BrainDocumentWriteInputKindSchema,
+	outcome: BrainDocumentWriteOutcomeSchema,
+	failureCode: z.string().trim().min(1).max(128).nullable().optional(),
+	failureMessage: z.string().trim().min(1).max(2e3).nullable().optional(),
+	submittedAt: z.string().datetime(),
+	contentReceivedAt: z.string().datetime().nullable().optional(),
+	completedAt: 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 = z.object({
+	documentId: BrainDocumentIdSchema,
+	title: 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: z.string().nullable(),
+	/** Caller-supplied revision fingerprint from the last put. */
+	revision: z.string().nullable(),
+	failureCode: BrainDocumentFailureCodeSchema.nullable().optional(),
+	failureMessage: z.string().nullable().optional(),
+	byteSize: z.number().int().nonnegative().nullable().optional(),
+	chunkCount: 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: z.string().datetime(),
+	updatedAt: z.string().datetime()
+});
+BrainDocumentSummarySchema.extend({
+	metadata: BrainDocumentMetadataSchema.nullable(),
+	contentType: z.string().nullable(),
+	format: z.string().nullable()
+});
+/** Accepts one repeated query param or an array; normalizes to an array. */
+function queryList(schema) {
+	return z.union([schema, z.array(schema).min(1)]).transform((value) => Array.isArray(value) ? value : [value]).optional();
+}
+const ListBrainDocumentsQuerySchema = z.object({
+	/** Filters documentIds by prefix (e.g. `slack:C123:`). */
+	prefix: z.string().min(1).max(512).optional(),
+	/** Case-insensitive substring over title and documentId. */
+	search: 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: z.string().min(1).optional(),
+	limit: z.coerce.number().int().min(1).max(500).default(100)
+});
+z.object({
+	documents: z.array(BrainDocumentSummarySchema),
+	nextCursor: z.string().nullable()
+});
+z.object({
+	documentId: BrainDocumentIdSchema,
+	cursor: z.string().min(1).optional(),
+	limit: z.coerce.number().int().min(1).max(100).default(50)
+});
+z.object({
+	writes: z.array(BrainDocumentWriteEventSchema),
+	nextCursor: z.string().nullable()
+});
+const BrainUploadFileInputSchema = z.object({
+	idempotencyId: z.string().uuid(),
+	/** Doubles as the documentId; normalized as a relative path. */
+	documentId: BrainDocumentIdSchema,
+	size: z.number().int().nonnegative().max(BRAIN_MAX_FILE_BYTES),
+	contentType: 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()
+});
+z.object({ files: z.array(BrainUploadFileInputSchema).min(1).max(BRAIN_MAX_FOLDER_FILES) }).strict();
+const BrainUploadAcceptedSchema = z.object({
+	idempotencyId: z.string().uuid(),
+	documentId: BrainDocumentIdSchema,
+	versionId: 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: z.object({
+		method: z.literal("POST"),
+		url: z.string().url(),
+		fields: z.record(z.string(), z.string())
+	}).nullable()
+});
+const BrainUploadSkippedSchema = z.object({
+	documentId: BrainDocumentIdSchema,
+	reason: BrainSkippedReasonSchema,
+	message: z.string().min(1).optional()
+});
+z.object({
+	accepted: z.array(BrainUploadAcceptedSchema),
+	skipped: z.array(BrainUploadSkippedSchema)
+});
+z.object({ versionIds: z.array(z.string().min(1)).min(1).max(100) }).strict();
+const FinalizeBrainUploadResultSchema = z.object({
+	versionId: z.string().min(1),
+	documentId: BrainDocumentIdSchema,
+	status: BrainDocumentVersionStatusSchema,
+	failureCode: BrainDocumentFailureCodeSchema.nullable().optional(),
+	failureMessage: z.string().nullable().optional()
+});
+z.object({ results: z.array(FinalizeBrainUploadResultSchema) });
+/** `hybrid` = ANN + BM25 with server fusion; `semantic` / `keyword` drop one leg. */
+const BrainSearchModeSchema = z.enum([
+	"hybrid",
+	"semantic",
+	"keyword"
+]);
+z.object({
+	query: z.string().trim().min(1).max(4e3),
+	mode: BrainSearchModeSchema.default("hybrid"),
+	limit: z.number().int().min(1).max(20).default(5),
+	minScore: z.number().min(0).max(1).optional(),
+	rerank: z.boolean().default(true),
+	/** Query-time narrowing; ANDs with the persisted filter when a qualified reference is searched. */
+	filters: BrainFilterExpressionSchema.optional()
+}).strict();
+const BrainSearchHitSchema = z.object({
+	/** Reference the hit was served through (qualified when searching a filter). */
+	brain: BrainReferenceSchema,
+	documentId: BrainDocumentIdSchema,
+	chunkId: z.string().min(1),
+	score: z.number(),
+	title: z.string().min(1),
+	text: z.string().min(1),
+	/** Where the document's content originated. */
+	source: BrainSourceSchema,
+	/** Human-readable location within the document (page/slide/heading) when known. */
+	locationLabel: z.string().nullable(),
+	metadata: BrainDocumentMetadataSchema.nullable()
+});
+z.object({
+	hits: z.array(BrainSearchHitSchema),
+	reranked: z.boolean()
+});
+z.object({
+	query: z.string().trim().min(1).max(4e3),
+	hits: z.array(BrainSearchHitSchema).min(1).max(320),
+	limit: z.number().int().min(1).max(20)
+}).strict();
+z.object({
+	offset: z.coerce.number().int().nonnegative().default(0),
+	maxChars: z.coerce.number().int().min(1).max(BRAIN_READ_MAX_CHARS).default(BRAIN_READ_MAX_CHARS)
+});
+z.object({
+	brain: BrainReferenceSchema,
+	documentId: BrainDocumentIdSchema,
+	title: z.string().min(1),
+	offset: z.number().int().nonnegative(),
+	text: z.string(),
+	truncated: z.boolean()
+});
+z.object({
+	/** Reference the agent addresses (base slug or qualified `{brain}:{filter}`). */
+	slug: BrainReferenceSchema,
+	name: 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()
+});
+z.object({
+	brainId: z.string().min(1),
+	status: BrainStatusSchema,
+	/** Namespace generation the rebuild is writing into. */
+	targetGeneration: z.number().int().positive()
+});
+const BrainOperationIdSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const BrainRuntimeJobCommonSchema = z.object({
+	operationId: BrainOperationIdSchema,
+	/** Originating project for workflow-scoped jobs; null for organization-scoped
+	* operations (manual uploads, admin rebuilds/deletes). */
+	projectId: z.string().min(1).nullable(),
+	brainId: z.string().min(1),
+	brainSlug: BrainSlugSchema
+}).strict();
+z.discriminatedUnion("operation", [
+	BrainRuntimeJobCommonSchema.extend({
+		operation: z.literal("ingest-version"),
+		versionId: z.string().min(1)
+	}),
+	BrainRuntimeJobCommonSchema.extend({ operation: z.literal("rebuild-brain") }),
+	BrainRuntimeJobCommonSchema.extend({
+		operation: z.literal("reconcile-metadata"),
+		documentId: BrainDocumentIdSchema
+	}),
+	BrainRuntimeJobCommonSchema.extend({
+		operation: z.literal("cleanup-document"),
+		documentRowId: z.string().min(1),
+		deletionEpoch: z.number().int().positive(),
+		versionIds: z.array(z.string().min(1))
+	}),
+	BrainRuntimeJobCommonSchema.extend({
+		operation: z.literal("cleanup-version"),
+		versionId: z.string().min(1)
+	}),
+	BrainRuntimeJobCommonSchema.extend({
+		operation: z.literal("cleanup-generation"),
+		generation: z.number().int().positive()
+	}),
+	BrainRuntimeJobCommonSchema.extend({ operation: z.literal("delete-brain") })
+]);
 const TriggerTypeSchema = z.enum([
 	"webhook",
 	"poll",
@@ -1416,6 +2045,7 @@ const WorkflowCanvasNodeTypeSchema = z.enum([
 z.enum([
 	"workflow-step",
 	"agent",
+	"brain",
 	"llm",
 	"wait",
 	"hook",
@@ -1627,6 +2257,7 @@ const storedRouteManifestEntryV2Schema = z.discriminatedUnion("kind", [
 		toolCount: z.number().int().nonnegative(),
 		credentialCount: z.number().int().nonnegative(),
 		sandboxMode: AgentSandboxModeSchema.optional(),
+		brainSlugs: z.array(BrainReferenceSchema).default([]),
 		appSlugs: z.array(z.string()).default([]),
 		toolSlugs: z.array(z.string()).default([]),
 		/** Credential requirements per tool slug (the agent's credential consumer key). */
@@ -1777,6 +2408,7 @@ const AgentManifestShardSchema = z.object({
 	toolCount: z.number().int().nonnegative(),
 	credentialCount: z.number().int().nonnegative(),
 	sandboxMode: AgentSandboxModeSchema.optional(),
+	brainSlugs: z.array(BrainReferenceSchema).default([]),
 	appSlugs: z.array(z.string()).default([]),
 	toolSlugs: z.array(z.string()).default([]),
 	toolRequirements: z.record(z.string(), z.array(CredentialRequirementSummarySchema)).optional(),
@@ -3171,6 +3803,20 @@ const SubmitMarketingContactRequestSchema = z.object({
 	companyWebsite: 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 = z.object({
+	id: BrainEmbeddingModelSchema,
+	name: z.string().min(1),
+	provider: z.string().min(1),
+	contextWindow: z.number().int().positive().optional(),
+	/** USD per 1M input tokens, when the catalog prices the model. */
+	inputPerMillionUsd: z.number().nonnegative().optional()
+});
+z.object({ models: z.array(EmbeddingModelSchema) });
 const CredentialAccessUnavailableReasonSchema = z.enum(["request_access", "reconnect_required"]);
 z.object({
 	error: z.literal("credential_access_unavailable"),
@@ -4772,7 +5418,7 @@ const ModuleBlobRefSchema = z.object({
 });
 const isoDateTime = z.string().datetime();
 /** Snapshot/content-addressed blob digests are always lowercase sha256. */
-const sha256Hex$2 = z.string().regex(/^[a-f0-9]{64}$/, "Expected a lowercase hex sha256 digest");
+const sha256Hex$3 = 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 = z.object({
 z.object({
 	path: z.string().min(1),
 	contents: z.string(),
-	hash: sha256Hex$2
+	hash: sha256Hex$3
 });
 /** A blob the CLI may need to upload, keyed by content hash. */
 const SourceBlobRefSchema = z.object({
-	hash: sha256Hex$2,
+	hash: sha256Hex$3,
 	size: z.number().int().nonnegative()
 });
 /** Request: ask the platform which blobs are missing and get presigned PUTs. */
 const PresignProjectSourceRequestSchema = z.object({ blobs: z.array(SourceBlobRefSchema) });
 const PresignedBlobUploadSchema = z.object({
-	hash: sha256Hex$2,
+	hash: sha256Hex$3,
 	url: z.string().url()
 });
 /** Response: presigned PUTs for the subset of blobs not already stored. */
@@ -4869,7 +5515,7 @@ const PresignProjectSourceResponseSchema = z.object({ uploads: z.array(Presigned
 /** A file reference in a manifest upload: where the path's content lives. */
 const ManifestFileRefSchema = z.object({
 	path: z.string().min(1),
-	hash: sha256Hex$2
+	hash: sha256Hex$3
 });
 /** Request body the CLI sends to finalize a deploy's source manifest. */
 const UploadProjectSourceManifestRequestSchema = z.object({ files: z.array(ManifestFileRefSchema) });
@@ -4881,7 +5527,7 @@ const UploadProjectSourceResponseSchema = z.object({
 const StoredManifestFileSchema = z.object({
 	id: z.string(),
 	path: z.string().min(1),
-	hash: sha256Hex$2
+	hash: sha256Hex$3
 });
 /** The immutable per-deploy manifest persisted to object storage. */
 const StoredProjectSourceManifestSchema = 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 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 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 DeleteObjectCommand({
 				Bucket: config.bucket,
@@ -6482,21 +7175,6 @@ function extractRouteManifestFromArtifact(archive) {
 		});
 	}
 }
-/** Lowercase hex sha256 of raw bytes. */
-function sha256Hex(bytes) {
-	return 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). */
@@ -6812,6 +7531,6 @@ async function publishDraftUpdateBestEffort(notifier, input) {
 	}
 }
 //#endregion
-export { CompleteManagedDeployArtifactResponseSchema as $, projectFileId as $i, PublicFormSubmitResponseSchema as $n, UserPreferencesSchema as $r, ListAgentWorkspaceFilesResponseSchema as $t, projectArtifactKey as A, resolvePublicPlatformApiOrigin as Aa, isProbablyBinaryProjectSource as Ai, PROJECT_SOURCE_MAX_FILE_BYTES as An, SubmitTeamRequestRequestSchema as Ar, DraftRevisionResponseSchema as At, AgentEnvImageSnapshotResponseSchema as B, mapProjectDeployment as Bi, PresignUserAvatarRequestSchema as Bn, UpdateManagedServiceCredentialRequestSchema as Br, GetTemplateResponseSchema as Bt, loadProjectSourceFiles as C, mintOrgWorkerToken as Ca, displayCredentialAppName as Ci, OpenApiDiscoverResponseSchema as Cn, StartMcpOAuthConnectionInputSchema as Cr, DbProxyQueryRequestSchema as Ct, prefetchCanvasShards as D, waitForHealth as Da, isHelloWorldTemplateSlug as Di, PROJECT_DRAFT_DIFF_MAX_BYTES as Dn, SubmitAgentFeedbackResponseSchema as Dr, DraftCommitResponseSchema as Dt, orgLogoStorageKey as E, verifyOrgWorkerToken as Ea, isDraftSnapshotPlaceholderCommitSha as Ei, PLATFORM_RESOURCE_UNSUPPORTED_TEXT as En, SubmitAgentFeedbackRequestSchema as Er, DownloadActiveProjectSourceResponseSchema as Et, userAvatarStorageKey as F, listenPortFromPublicUrl as Fi, PresignCustomAppLogoResponseSchema as Fn, TriggerInvokeInputsSchema as Fr, FinalizeCustomAppLogoRequestSchema as Ft, AgentSummarySchema as G, mergeUserPreferences as Gi, ProjectReachabilityResponseSchema as Gn, UpdateProjectMemberResponseSchema as Gr, HistoryRunDetailResponseSchema as Gt, AgentMemoryFileSummarySchema as H, mapProjectSettings as Hi, ProjectGitRemoteRequestSchema as Hn, UpdateOrganizationMemberResponseSchema as Hr, GraphqlDiscoverResponseSchema as Ht, AcceptOrganizationInvitationResponseSchema as I, mapOrganizationInvitation as Ii, PresignOrgLogoRequestSchema as In, TriggerInvokeRequestSchema as Ir, FinalizeCustomAppLogoResponseSchema as It, AppSlugAvailabilityResponseSchema as J, openApiSpecToAppTemplate as Ji, ProjectSlugAvailabilityQuerySchema as Jn, UploadProjectSourceManifestRequestSchema as Jr, InviteOrganizationMembersRequestSchema as Jt, AgentWorkspaceFileSummarySchema as K, normalizeSlackAppHandle as Ki, ProjectResponseSchema as Kn, UpdateProjectRequestSchema as Kr, HistoryRunListQuerySchema as Kt, ActionsCatalogShardSchema as L, mapOrganizationMember as Li, PresignOrgLogoResponseSchema as Ln, TriggerInvokeResponseSchema as Lr, GetAppCatalogEntryResponseSchema as Lt, projectSourceBlobKey as M, isSlackCustomAppOauthSlug as Mi, PrepareManagedDeployRequestSchema as Mn, TemplateFilesResponseSchema as Mr, DuplicateCredentialRequestSchema as Mt, publicKeystrokeAssetsObjectUrl as N, jsonSchemaToWorkflowInputSchema as Ni, PrepareManagedDeployResponseSchema as Nn, TemplateKindSchema as Nr, DuplicateCredentialsResponseSchema as Nt, projectArtifactBlobKey as O, DEFAULT_CLOUD_PLATFORM_ORIGIN as Oa, isIgnoredProjectSourcePath as Oi, PROJECT_SLUG_TAKEN_MESSAGE as On, SubmitMarketingContactRequestSchema as Or, DraftConflictResponseSchema as Ot, sha256Hex as P, jsonSchemaToZod as Pi, PresignCustomAppLogoRequestSchema as Pn, TriggerAttachmentUpdateRequestSchema as Pr, ErrorResponseSchema as Pt, CompleteManagedDeployArtifactRequestSchema as Q, parseStoredRouteManifest as Qi, PublicFormSubmitBodySchema as Qn, UserPreferencesPatchSchema as Qr, ListAgentMemoryFilesResponseSchema as Qt, ActiveOrganizationResponseSchema as R, mapProject as Ri, PresignProjectSourceRequestSchema as Rn, TriggerRunListQuerySchema as Rr, GetCredentialResponseSchema as Rt, keystrokeAssetsOrgLogoKeyFromPublicUrl as S, formatDockerEnv as Sa, deriveCredentialInstanceSlug as Si, OpenApiDiscoverRequestSchema as Sn, SlugAvailabilityResponseSchema as Sr, DRAFT_SNAPSHOT_PLACEHOLDER_COMMIT_SHA as St, openModularArtifactShards as T, resolveWorkerRuntimeConfig as Ta, inferGraphqlAuthFromProbe as Ti, OrganizationSidebarBrandingSchema as Tn, StoredProjectSourceManifestSchema as Tr, DownloadActiveProjectArtifactResponseSchema as Tt, AgentSummaryDetailResponseSchema as U, mapUserOrganization as Ui, ProjectGitRemoteResponseSchema as Un, UpdateOrganizationRequestSchema as Ur, HeartbeatManagedDeployResponseSchema as Ut, AgentManifestShardSchema as V, mapProjectMember as Vi, PresignUserAvatarResponseSchema as Vn, UpdateOrganizationMemberRequestSchema as Vr, GraphqlDiscoverRequestSchema as Vt, AgentSummaryListResponseSchema as W, mcpProbeToAppTemplate as Wi, ProjectGitStatusResponseSchema as Wn, UpdateProjectMemberRequestSchema as Wr, HistoryRunCancelResponseSchema as Wt, CancelManagedDeployResponseSchema as X, organizationSlugErrorCodeFromMessage as Xi, ProjectSourceResourcesSchema as Xn, UserAvatarPatchSchema as Xr, InviteProjectMembersRequestSchema as Xt, CancelManagedDeployRequestSchema as Y, organizationInvitationAcceptPath as Yi, ProjectSlugAvailabilityResponseSchema as Yn, UploadProjectSourceResponseSchema as Yr, InviteOrganizationMembersResponseSchema as Yt, ChannelPlatformSchema as Z, parseAppSlug as Zi, PublicFormMetadataSchema as Zn, UserAvatarSchema as Zr, InviteProjectMembersResponseSchema as Zt, isStorageBucketNotFoundError as _, isAllowedChatAttachmentMediaType as _a, WorkspaceWorkflowOverviewSchema as _i, ListTemplatesResponseSchema as _n, SlackAppInstallStartResponseSchema as _r, CreateSlackAppRequestSchema as _t, createAssetsStorageClient as a, slackCustomAppHandleFromSlug as aa, WorkflowManifestFlowShardSchema as ai, ListDraftFilesResponseSchema as an, RecentResourceSchema as ar, CreateCredentialsRequestSchema as at, keystrokeAssetsAppLogoKeyFromPublicUrl as b, requiredDisplayTextSchema as ba, buildCredentialInstanceLabel as bi, McpDiscoverRequestSchema as bn, SlackAppManifestResponseSchema as br, DEFAULT_WORKFLOW_CANVAS_MODEL as bt, formatStorageErrorDetail as c, validateFormFieldConfig as ca, WorkflowRunInputsSchema as ci, ListOrganizationInvitationsResponseSchema as cn, SLACK_CUSTOM_APP_BOT_SCOPES as cr, CreateCustomAppResponseSchema as ct, isKeystrokeAssetsAppLogoPublicUrl as d, ACTIVE_ORG_HEADER as da, WorkflowSummarySchema as di, ListOrganizationsResponseSchema as dn, SLACK_GATEWAY_OAUTH_APP_KEY as dr, CreateOrganizationRequestSchema as dt, resolvePublicFormFields as ea, WorkflowCanvasCredentialBindingsSchema as ei, ListApiKeysResponseSchema as en, PublishManagedDeployCandidateRequestSchema as er, CompleteProjectArtifactRequestSchema as et, isKeystrokeAssetsAvatarPublicUrl as f, FilePartSchema as fa, WorkspaceTriggerDetailSchema as fi, ListProjectDeploymentsResponseSchema as fn, SLACK_KEYSTROKE_APP_BOT_SCOPES as fr, CreateOrganizationResponseSchema as ft, isProjectArtifactTarballKey as g, chatAttachmentExtension as ga, WorkspaceTriggerRunListResponseSchema as gi, ListProjectsResponseSchema as gn, SkillSummarySchema as gr, CreateProjectResponseSchema as gt, isProjectArtifactIndexKey as h, PublicModelsResponseSchema as ha, WorkspaceTriggerOverviewSchema as hi, ListProjectMetricsResponseSchema as hn, SkillSummaryListResponseSchema as hr, CreateProjectRequestSchema as ht, chatAttachmentStorageKey as i, slackAppBindingChannelId as ia, WorkflowFormUpsertBodySchema as ii, ListCredentialsPageResponseSchema as in, RecentResourceListResponseSchema as ir, CreateApiKeyResponseSchema as it, projectModuleBlobKey as j, resolvePublicPlatformOrigin as ja, isRecord as ji, PROJECT_SOURCE_MAX_TOTAL_BYTES as jn, SubmitTeamRequestResponseSchema as jr, DraftUpdateEventSchema as jt, projectArtifactIndexKey as k, resolveExternalPlatformOrigin as ka, isLlmProviderSlug as ki, PROJECT_SOURCE_MAX_FILES as kn, SubmitMarketingContactResponseSchema as kr, DraftFileContentQuerySchema as kt, isAppLogoStorageKey as l, validateWorkflowRunInputValues as la, WorkflowSummaryDetailResponseSchema as li, ListOrganizationMembersPageQuerySchema as ln, SLACK_CUSTOM_APP_CREDENTIAL_SLUG as lr, CreateDraftCommitRequestSchema as lt, isOrgLogoStorageKey as m, PresignChatAttachmentResponseSchema as ma, WorkspaceTriggerListResponseSchema as mi, ListProjectMembersResponseSchema as mn, SkillSummaryDetailResponseSchema as mr, CreateProjectArtifactResponseSchema as mt, publishDraftUpdateBestEffort as n, schemaHasFileFields as na, WorkflowCanvasSchema as ni, ListChannelPlatformsResponseSchema as nn, PublishedFormListResponseSchema as nr, ConnectManagedServiceCredentialRequestSchema as nt, ensureKeystrokeAssetsBucket as o, slackCustomAppOauthSlug as oa, WorkflowManifestMetaShardSchema as oi, ListManagedServiceCredentialsResponseSchema as on, RenewManagedDeployUploadRequestSchema as or, CreateCredentialsResponseSchema as ot, isKeystrokeAssetsOrgLogoPublicUrl as p, PresignChatAttachmentRequestSchema as pa, WorkspaceTriggerFileSchema as pi, ListProjectFilesResponseSchema as pn, SLACK_KEYSTROKE_APP_SLUG as pr, CreateProjectArtifactRequestSchema as pt, AppSlugAvailabilityQuerySchema as q, normalizeUserPreferences as qi, ProjectSettingsResponseSchema as qn, UpdateProjectSettingsRequestSchema as qr, HistoryRunListResponseSchema as qt, appLogoStorageKey as r, schemaHasUnsupportedFormFields as ra, WorkflowFormResponseSchema as ri, ListCredentialsPageQuerySchema as rn, PublishedFormSchema as rr, CreateApiKeyRequestSchema as rt, extractRouteManifestFromArtifact as s, validateCredentialValueAgainstFields as sa, WorkflowRunInputsPutBodySchema as si, ListMcpAppToolsResponseSchema as sn, RenewManagedDeployUploadResponseSchema as sr, CreateCustomAppRequestSchema as st, createInProcessProjectDraftNotifier as t, resolveUniqueCredentialInstanceLabel as ta, WorkflowCanvasRunSchema as ti, ListAppsResponseSchema as tn, PublishManagedDeployCandidateResponseSchema as tr, CompleteProjectArtifactResponseSchema as tt, isChatAttachmentStorageKey as u, validationErrorResponse as ua, WorkflowSummaryListResponseSchema as ui, ListOrganizationMembersPageResponseSchema as un, SLACK_CUSTOM_APP_SLUG_PREFIX as ur, CreateDraftDiffCommitRequestSchema as ut, isStorageNotFoundError as v, MICRO_CREDITS_PER_CREDIT as va, agentMemoryFileId as vi, ManagedServiceCredentialSchema as vn, SlackAppListResponseSchema as vr, CreateSlackAppResponseSchema as vt, minioStoragePlugin as w, resolveRuntimeLaunch as wa, graphqlIntrospectionToAppTemplate as wi, OrganizationSidebarBrandingPatchSchema as wn, StartMcpOAuthConnectionResultSchema as wr, DeclineOrganizationInvitationResponseSchema as wt, keystrokeAssetsAvatarKeyFromPublicUrl as x, PROJECT_SERVER_HEALTH as xa, buildSlackAppManifest as xi, McpDiscoverResponseSchema as xn, SlugAvailabilityQuerySchema as xr, DEFAULT_WORKFLOW_OVERVIEW_MODEL as xt, isUserAvatarStorageKey as y, credentialInputSchema as ya, agentWorkspaceFileId as yi, ManagedServiceKindSchema as yn, SlackAppManifestRequestSchema as yr, DEFAULT_TRIGGER_OVERVIEW_MODEL as yt, ActiveProjectSourceRevisionSchema as z, mapProjectArtifact as zi, PresignProjectSourceResponseSchema as zn, UpdateCredentialRequestSchema as zr, GetCustomAppResponseSchema as zt };
+export { AppSlugAvailabilityResponseSchema as $, mcpProbeToAppTemplate as $i, ProjectGitStatusResponseSchema as $n, UpdateProjectMemberRequestSchema as $r, HistoryRunDetailResponseSchema as $t, prefetchCanvasShards as A, PROJECT_SERVER_HEALTH as Aa, buildSlackAppManifest as Ai, McpDiscoverResponseSchema as An, SlugAvailabilityQuerySchema as Ar, DRAFT_SNAPSHOT_PLACEHOLDER_COMMIT_SHA as At, sha256Hex as B, resolvePublicPlatformOrigin as Ba, isRecord as Bi, PROJECT_SOURCE_MAX_TOTAL_BYTES as Bn, SubmitTeamRequestResponseSchema as Br, DuplicateCredentialRequestSchema as Bt, keystrokeAssetsAppLogoKeyFromPublicUrl as C, PresignChatAttachmentResponseSchema as Ca, WorkspaceTriggerListResponseSchema as Ci, ListProjectMembersResponseSchema as Cn, SkillSummaryDetailResponseSchema as Cr, CreateProjectRequestSchema as Ct, minioStoragePlugin as D, MICRO_CREDITS_PER_CREDIT as Da, agentMemoryFileId as Di, ManagedServiceCredentialSchema as Dn, SlackAppListResponseSchema as Dr, DEFAULT_TRIGGER_OVERVIEW_MODEL as Dt, loadProjectSourceFiles as E, isAllowedChatAttachmentMediaType as Ea, WorkspaceWorkflowOverviewSchema as Ei, ListTemplatesResponseSchema as En, SlackAppInstallStartResponseSchema as Er, CreateSlackAppResponseSchema as Et, projectSourceBlobKey as F, verifyOrgWorkerToken as Fa, isDraftSnapshotPlaceholderCommitSha as Fi, PLATFORM_RESOURCE_UNSUPPORTED_TEXT as Fn, SubmitAgentFeedbackRequestSchema as Fr, DraftCommitResponseSchema as Ft, AgentEnvImageSnapshotResponseSchema as G, mapOrganizationInvitation as Gi, PresignOrgLogoRequestSchema as Gn, TriggerInvokeRequestSchema as Gr, GetAppCatalogEntryResponseSchema as Gt, ActionsCatalogShardSchema as H, jsonSchemaToWorkflowInputSchema as Hi, PrepareManagedDeployResponseSchema as Hn, TemplateKindSchema as Hr, ErrorResponseSchema as Ht, publicKeystrokeAssetsObjectUrl as I, waitForHealth as Ia, isHelloWorldTemplateSlug as Ii, PROJECT_DRAFT_DIFF_MAX_BYTES as In, SubmitAgentFeedbackResponseSchema as Ir, DraftConflictResponseSchema as It, AgentSummaryDetailResponseSchema as J, mapProjectArtifact as Ji, PresignProjectSourceResponseSchema as Jn, UpdateCredentialRequestSchema as Jr, GetTemplateResponseSchema as Jt, AgentManifestShardSchema as K, mapOrganizationMember as Ki, PresignOrgLogoResponseSchema as Kn, TriggerInvokeResponseSchema as Kr, GetCredentialResponseSchema as Kt, putBrowserProfileMeta as L, DEFAULT_CLOUD_PLATFORM_ORIGIN as La, isIgnoredProjectSourcePath as Li, PROJECT_SLUG_TAKEN_MESSAGE as Ln, SubmitMarketingContactRequestSchema as Lr, DraftFileContentQuerySchema as Lt, projectArtifactIndexKey as M, mintOrgWorkerToken as Ma, displayCredentialAppName as Mi, OpenApiDiscoverResponseSchema as Mn, StartMcpOAuthConnectionInputSchema as Mr, DeclineOrganizationInvitationResponseSchema as Mt, projectArtifactKey as N, resolveRuntimeLaunch as Na, graphqlIntrospectionToAppTemplate as Ni, OrganizationSidebarBrandingPatchSchema as Nn, StartMcpOAuthConnectionResultSchema as Nr, DownloadActiveProjectArtifactResponseSchema as Nt, openModularArtifactShards as O, credentialInputSchema as Oa, agentWorkspaceFileId as Oi, ManagedServiceKindSchema as On, SlackAppManifestRequestSchema as Or, DEFAULT_WORKFLOW_CANVAS_MODEL as Ot, projectModuleBlobKey as P, resolveWorkerRuntimeConfig as Pa, inferGraphqlAuthFromProbe as Pi, OrganizationSidebarBrandingSchema as Pn, StoredProjectSourceManifestSchema as Pr, DownloadActiveProjectSourceResponseSchema as Pt, AppSlugAvailabilityQuerySchema as Q, mapUserOrganization as Qi, ProjectGitRemoteResponseSchema as Qn, UpdateOrganizationRequestSchema as Qr, HistoryRunCancelResponseSchema as Qt, putBrowserSessionMeta as R, resolveExternalPlatformOrigin as Ra, isLlmProviderSlug as Ri, PROJECT_SOURCE_MAX_FILES as Rn, SubmitMarketingContactResponseSchema as Rr, DraftRevisionResponseSchema as Rt, isUserAvatarStorageKey as S, PresignChatAttachmentRequestSchema as Sa, WorkspaceTriggerFileSchema as Si, ListProjectFilesResponseSchema as Sn, SLACK_KEYSTROKE_APP_SLUG as Sr, CreateProjectArtifactResponseSchema as St, keystrokeAssetsOrgLogoKeyFromPublicUrl as T, chatAttachmentExtension as Ta, WorkspaceTriggerRunListResponseSchema as Ti, ListProjectsResponseSchema as Tn, SkillSummarySchema as Tr, CreateSlackAppRequestSchema as Tt, ActiveOrganizationResponseSchema as U, jsonSchemaToZod as Ui, PresignCustomAppLogoRequestSchema as Un, TriggerAttachmentUpdateRequestSchema as Ur, FinalizeCustomAppLogoRequestSchema as Ut, AcceptOrganizationInvitationResponseSchema as V, isSlackCustomAppOauthSlug as Vi, PrepareManagedDeployRequestSchema as Vn, TemplateFilesResponseSchema as Vr, DuplicateCredentialsResponseSchema as Vt, ActiveProjectSourceRevisionSchema as W, listenPortFromPublicUrl as Wi, PresignCustomAppLogoResponseSchema as Wn, TriggerInvokeInputsSchema as Wr, FinalizeCustomAppLogoResponseSchema as Wt, AgentSummarySchema as X, mapProjectMember as Xi, PresignUserAvatarResponseSchema as Xn, UpdateOrganizationMemberRequestSchema as Xr, GraphqlDiscoverResponseSchema as Xt, AgentSummaryListResponseSchema as Y, mapProjectDeployment as Yi, PresignUserAvatarRequestSchema as Yn, UpdateManagedServiceCredentialRequestSchema as Yr, GraphqlDiscoverRequestSchema as Yt, AgentWorkspaceFileSummarySchema as Z, mapProjectSettings as Zi, ProjectGitRemoteRequestSchema as Zn, UpdateOrganizationMemberResponseSchema as Zr, HeartbeatManagedDeployResponseSchema as Zt, isOrgLogoStorageKey as _, validateFormFieldConfig as _a, WorkflowRunInputsSchema as _i, ListOrganizationInvitationsResponseSchema as _n, SLACK_CUSTOM_APP_BOT_SCOPES as _r, CreateDraftCommitRequestSchema as _t, createAssetsStorageClient as a, organizationSlugErrorCodeFromMessage as aa, UserAvatarPatchSchema as ai, InviteProjectMembersResponseSchema as an, ProjectSourceResourcesSchema as ar, ChannelPlatformSchema as at, isStorageBucketNotFoundError as b, ACTIVE_ORG_HEADER as ba, WorkflowSummarySchema as bi, ListOrganizationsResponseSchema as bn, SLACK_GATEWAY_OAUTH_APP_KEY as br, CreateOrganizationResponseSchema as bt, formatStorageErrorDetail as c, projectFileId as ca, UserPreferencesSchema as ci, ListApiKeysResponseSchema as cn, PublicFormSubmitResponseSchema as cr, CompleteProjectArtifactRequestSchema as ct, isAppLogoStorageKey as d, schemaHasFileFields as da, WorkflowCanvasSchema as di, ListChannelPlatformsResponseSchema as dn, PublishedFormListResponseSchema as dr, CreateApiKeyRequestSchema as dt, mergeUserPreferences as ea, UpdateProjectMemberResponseSchema as ei, HistoryRunListQuerySchema as en, ProjectReachabilityResponseSchema as er, BrainDocumentIdSchema as et, isBrowserMediaStorageKey as f, schemaHasUnsupportedFormFields as fa, WorkflowFormResponseSchema as fi, ListCredentialsPageQuerySchema as fn, PublishedFormSchema as fr, CreateApiKeyResponseSchema as ft, isKeystrokeAssetsOrgLogoPublicUrl as g, validateCredentialValueAgainstFields as ga, WorkflowRunInputsPutBodySchema as gi, ListMcpAppToolsResponseSchema as gn, RenewManagedDeployUploadResponseSchema as gr, CreateCustomAppResponseSchema as gt, isKeystrokeAssetsAvatarPublicUrl as h, slackCustomAppOauthSlug as ha, WorkflowManifestMetaShardSchema as hi, ListManagedServiceCredentialsResponseSchema as hn, RenewManagedDeployUploadRequestSchema as hr, CreateCustomAppRequestSchema as ht, chatAttachmentStorageKey as i, organizationInvitationAcceptPath as ia, UploadProjectSourceResponseSchema as ii, InviteProjectMembersRequestSchema as in, ProjectSlugAvailabilityResponseSchema as ir, CancelManagedDeployResponseSchema as it, projectArtifactBlobKey as j, formatDockerEnv as ja, deriveCredentialInstanceSlug as ji, OpenApiDiscoverRequestSchema as jn, SlugAvailabilityResponseSchema as jr, DbProxyQueryRequestSchema as jt, orgLogoStorageKey as k, requiredDisplayTextSchema as ka, buildCredentialInstanceLabel as ki, McpDiscoverRequestSchema as kn, SlackAppManifestResponseSchema as kr, DEFAULT_WORKFLOW_OVERVIEW_MODEL as kt, getBrowserProfileMeta as l, resolvePublicFormFields as la, WorkflowCanvasCredentialBindingsSchema as li, ListAppsResponseSchema as ln, PublishManagedDeployCandidateRequestSchema as lr, CompleteProjectArtifactResponseSchema as lt, isKeystrokeAssetsAppLogoPublicUrl as m, slackCustomAppHandleFromSlug as ma, WorkflowManifestFlowShardSchema as mi, ListDraftFilesResponseSchema as mn, RecentResourceSchema as mr, CreateCredentialsResponseSchema as mt, publishDraftUpdateBestEffort as n, normalizeUserPreferences as na, UpdateProjectSettingsRequestSchema as ni, InviteOrganizationMembersRequestSchema as nn, ProjectSettingsResponseSchema as nr, BrowserResumeStateSchema as nt, ensureKeystrokeAssetsBucket as o, parseAppSlug as oa, UserAvatarSchema as oi, ListAgentMemoryFilesResponseSchema as on, PublicFormMetadataSchema as or, CompleteManagedDeployArtifactRequestSchema as ot, isChatAttachmentStorageKey as p, slackAppBindingChannelId as pa, WorkflowFormUpsertBodySchema as pi, ListCredentialsPageResponseSchema as pn, RecentResourceListResponseSchema as pr, CreateCredentialsRequestSchema as pt, AgentMemoryFileSummarySchema as q, mapProject as qi, PresignProjectSourceRequestSchema as qn, TriggerRunListQuerySchema as qr, GetCustomAppResponseSchema as qt, appLogoStorageKey as r, openApiSpecToAppTemplate as ra, UploadProjectSourceManifestRequestSchema as ri, InviteOrganizationMembersResponseSchema as rn, ProjectSlugAvailabilityQuerySchema as rr, CancelManagedDeployRequestSchema as rt, extractRouteManifestFromArtifact as s, parseStoredRouteManifest as sa, UserPreferencesPatchSchema as si, ListAgentWorkspaceFilesResponseSchema as sn, PublicFormSubmitBodySchema as sr, CompleteManagedDeployArtifactResponseSchema as st, createInProcessProjectDraftNotifier as t, normalizeSlackAppHandle as ta, UpdateProjectRequestSchema as ti, HistoryRunListResponseSchema as tn, ProjectResponseSchema as tr, BrainReferenceSchema as tt, getBrowserSessionMeta as u, resolveUniqueCredentialInstanceLabel as ua, WorkflowCanvasRunSchema as ui, ListBrainDocumentsQuerySchema as un, PublishManagedDeployCandidateResponseSchema as ur, ConnectManagedServiceCredentialRequestSchema as ut, isProjectArtifactIndexKey as v, validateWorkflowRunInputValues as va, WorkflowSummaryDetailResponseSchema as vi, ListOrganizationMembersPageQuerySchema as vn, SLACK_CUSTOM_APP_CREDENTIAL_SLUG as vr, CreateDraftDiffCommitRequestSchema as vt, keystrokeAssetsAvatarKeyFromPublicUrl as w, PublicModelsResponseSchema as wa, WorkspaceTriggerOverviewSchema as wi, ListProjectMetricsResponseSchema as wn, SkillSummaryListResponseSchema as wr, CreateProjectResponseSchema as wt, isStorageNotFoundError as x, FilePartSchema as xa, WorkspaceTriggerDetailSchema as xi, ListProjectDeploymentsResponseSchema as xn, SLACK_KEYSTROKE_APP_BOT_SCOPES as xr, CreateProjectArtifactRequestSchema as xt, isProjectArtifactTarballKey as y, validationErrorResponse as ya, WorkflowSummaryListResponseSchema as yi, ListOrganizationMembersPageResponseSchema as yn, SLACK_CUSTOM_APP_SLUG_PREFIX as yr, CreateOrganizationRequestSchema as yt, userAvatarStorageKey as z, resolvePublicPlatformApiOrigin as za, isProbablyBinaryProjectSource as zi, PROJECT_SOURCE_MAX_FILE_BYTES as zn, SubmitTeamRequestRequestSchema as zr, DraftUpdateEventSchema as zt };
 
-//# sourceMappingURL=project-draft-notifier-B7K0aaAp.mjs.map
+//# sourceMappingURL=project-draft-notifier-DbGvx0CD.mjs.map