lopata 0.19.2 → 0.20.1

package/src/cli/dev.ts

@@ -24,13 +24,14 @@ import {
 	setRouteDispatcher,
 	setWorkerRegistry,
 } from '../api'
+import { handleArtifactsGitRequest } from '../bindings/artifacts-git-http'
 import { reapOrphanContainers } from '../bindings/container-cleanup'
 import { QueuePullConsumer } from '../bindings/queue'
 import type { AckRequest, PullRequest } from '../bindings/queue'
 import { CFWebSocket } from '../bindings/websocket-pair'
 import { autoLoadConfig, findConfigPath, loadConfig } from '../config'
 import { handleDashboardRequest } from '../dashboard-serve'
-import { getDatabase } from '../db'
+import { getDatabase, getDataDir } from '../db'
 import { FileWatcher } from '../file-watcher'
 import { GenerationManager } from '../generation-manager'
 import { ImportGraphWatcher } from '../import-graph'
@@ -63,6 +64,15 @@ export async function run(ctx: CliContext, args: string[]) {
 	const envFlag = ctx.envName
 	const portFlag = values.port
 
+	// Resolve port + host early so baseUrls (e.g. the Artifacts git remote) can be
+	// built before the generation managers, which pass it into their worker threads.
+	const earlyPort = parseInt(portFlag ?? process.env.PORT ?? '8787', 10)
+	const earlyHost = values.host ? '0.0.0.0' : (values.listen ?? process.env.HOST ?? 'localhost')
+	const artifactsHost = earlyHost === '0.0.0.0' ? 'localhost' : earlyHost
+	const baseUrls = {
+		artifacts: process.env.LOPATA_ARTIFACTS_BASE_URL ?? `http://${artifactsHost}:${earlyPort}/__artifacts/git`,
+	}
+
 	const baseDir = process.cwd()
 	const watchers: { stop(): void }[] = []
 
@@ -117,6 +127,7 @@ export async function run(ctx: CliContext, args: string[]) {
 			executorFactory: await makeExecutorFactory(),
 			configPath: lopataConfig.main,
 			browserConfig: lopataConfig.browser,
+			baseUrls,
 		})
 		registry.register(mainConfig.name, mainManager, true)
 
@@ -135,6 +146,7 @@ export async function run(ctx: CliContext, args: string[]) {
 				cron: lopataConfig.cron,
 				executorFactory: await makeExecutorFactory(),
 				configPath: workerDef.config,
+				baseUrls,
 			})
 			registry.register(workerDef.name, auxManager)
 
@@ -273,6 +285,7 @@ export async function run(ctx: CliContext, args: string[]) {
 			isMain: true,
 			executorFactory,
 			configPath: findConfigPath(baseDir),
+			baseUrls,
 		})
 		registry.register(config.name, manager, true)
 		const firstGen = await manager.reload()
@@ -306,8 +319,8 @@ export async function run(ctx: CliContext, args: string[]) {
 	}
 
 	// Start server — one Bun.serve(), delegates to active generation
-	const port = parseInt(portFlag ?? process.env.PORT ?? '8787', 10)
-	const hostname = values.host ? '0.0.0.0' : (values.listen ?? process.env.HOST ?? 'localhost')
+	const port = earlyPort
+	const hostname = earlyHost
 
 	const server = Bun.serve({
 		port,
@@ -334,6 +347,15 @@ export async function run(ctx: CliContext, args: string[]) {
 				return handleDashboardRequest(request)
 			}
 
+			// Artifacts git HTTP backend (clone/fetch/push) — backed by `git http-backend`.
+			if (url.pathname.startsWith('/__artifacts/git/')) {
+				const resp = await handleArtifactsGitRequest(request, {
+					db: getDatabase(),
+					artifactsDir: path.join(getDataDir(), 'artifacts'),
+				})
+				if (resp) return resp
+			}
+
 			// S3-compatible proxy: /__s3/{bucket}/{key...} → R2 binding on active worker
 			const s3Match = matchS3Path(url.pathname)
 			if (s3Match) {

package/src/config.ts

@@ -31,13 +31,32 @@ export interface WranglerConfig {
 		name: string
 		destination_address?: string
 		allowed_destination_addresses?: string[]
+		remote?: boolean
 	}[]
 	ai?: { binding: string }
+	ai_search_namespaces?: {
+		binding: string
+		namespace: string
+		remote?: boolean
+	}[]
+	artifacts?: {
+		binding: string
+		namespace: string
+	}[]
+	worker_loaders?: {
+		binding: string
+	}[]
 	hyperdrive?: {
 		binding: string
 		id: string
 		localConnectionString?: string
 	}[]
+	vpc_networks?: {
+		binding: string
+		network_id?: string
+		tunnel_id?: string
+		remote?: boolean
+	}[]
 	services?: { binding: string; service: string; entrypoint?: string; props?: Record<string, unknown> }[]
 	triggers?: { crons?: string[] }
 	vars?: Record<string, string>
@@ -65,6 +84,7 @@ export interface WranglerConfig {
 	analytics_engine_datasets?: { binding: string; dataset?: string }[]
 	browser?: { binding: string }
 	version_metadata?: { binding: string }
+	flagship?: { binding: string; app_id: string }
 	migrations?: {
 		tag: string
 		new_classes?: string[]

package/src/db.ts

@@ -257,6 +257,60 @@ export function runMigrations(db: Database): void {
 			tag TEXT PRIMARY KEY
 		)
 	`)
+
+	db.run(`
+		CREATE TABLE IF NOT EXISTS artifacts_repos (
+			id TEXT PRIMARY KEY,
+			namespace TEXT NOT NULL,
+			name TEXT NOT NULL,
+			description TEXT,
+			default_branch TEXT NOT NULL DEFAULT 'main',
+			read_only INTEGER NOT NULL DEFAULT 0,
+			forked_from TEXT,
+			created_at INTEGER NOT NULL,
+			UNIQUE(namespace, name)
+		)
+	`)
+
+	db.run(`
+		CREATE TABLE IF NOT EXISTS artifacts_tokens (
+			id TEXT PRIMARY KEY,
+			repo_id TEXT NOT NULL,
+			plaintext TEXT NOT NULL,
+			scope TEXT NOT NULL DEFAULT 'write',
+			expires_at INTEGER,
+			created_at INTEGER NOT NULL,
+			revoked_at INTEGER
+		)
+	`)
+	db.run(`CREATE INDEX IF NOT EXISTS idx_artifacts_tokens_repo ON artifacts_tokens(repo_id)`)
+
+	db.run(`
+		CREATE TABLE IF NOT EXISTS ai_search_requests (
+			id TEXT PRIMARY KEY,
+			namespace TEXT NOT NULL,
+			operation TEXT NOT NULL,
+			input_summary TEXT,
+			output_summary TEXT,
+			duration_ms INTEGER NOT NULL,
+			status TEXT NOT NULL DEFAULT 'ok',
+			error TEXT,
+			created_at INTEGER NOT NULL
+		)
+	`)
+	db.run(`CREATE INDEX IF NOT EXISTS idx_ai_search_requests_ts ON ai_search_requests(created_at)`)
+
+	db.run(`
+		CREATE TABLE IF NOT EXISTS flagship_flags (
+			app_id TEXT NOT NULL,
+			flag_key TEXT NOT NULL,
+			type TEXT NOT NULL,
+			value TEXT NOT NULL,
+			variant TEXT,
+			updated_at INTEGER NOT NULL,
+			PRIMARY KEY (app_id, flag_key)
+		)
+	`)
 }
 
 /** Returns the path to the .lopata data directory. */

package/src/env.ts

@@ -1,7 +1,9 @@
 import { existsSync, readFileSync, renameSync, rmSync } from 'node:fs'
 import path from 'node:path'
 import { AiBinding } from './bindings/ai'
+import { AiSearchNamespaceBinding } from './bindings/ai-search'
 import { SqliteAnalyticsEngine } from './bindings/analytics-engine'
+import { ArtifactsBinding } from './bindings/artifacts'
 import { BrowserBinding } from './bindings/browser'
 import { ContainerBase } from './bindings/container'
 import { containerLabels, registerContainer, unregisterContainer } from './bindings/container-cleanup'
@@ -10,6 +12,7 @@ import { openD1Database } from './bindings/d1'
 import type { DOExecutorFactory } from './bindings/do-executor'
 import { DurableObjectNamespaceImpl } from './bindings/durable-object'
 import { SendEmailBinding } from './bindings/email'
+import { FlagshipBinding } from './bindings/flagship'
 import { HyperdriveBinding } from './bindings/hyperdrive'
 import { ImagesBinding } from './bindings/images'
 import { SqliteKVNamespace } from './bindings/kv'
@@ -18,6 +21,8 @@ import { QueueConsumer, SqliteQueueProducer } from './bindings/queue'
 import { FileR2Bucket } from './bindings/r2'
 import { createServiceBinding } from './bindings/service-binding'
 import { StaticAssets } from './bindings/static-assets'
+import { VpcNetworkBinding } from './bindings/vpc-network'
+import { WorkerLoaderBinding } from './bindings/worker-loader'
 import { SqliteWorkflowBinding, wireWorkflowClass } from './bindings/workflow'
 import type { WranglerConfig } from './config'
 import { getDatabase, getDataDir } from './db'
@@ -88,6 +93,7 @@ export function buildEnv(
 	executorFactory?: DOExecutorFactory,
 	browserConfig?: { wsEndpoint?: string; executablePath?: string; headless?: boolean },
 	existingNamespaces?: Map<string, DurableObjectNamespaceImpl>,
+	baseUrls?: { artifacts?: string },
 ): { env: Record<string, unknown>; registry: ClassRegistry } {
 	const env: Record<string, unknown> = {}
 	const registry: ClassRegistry = { durableObjects: [], workflows: [], containers: [], queueConsumers: [], serviceBindings: [], staticAssets: null }
@@ -363,6 +369,71 @@ export function buildEnv(
 		)
 	}
 
+	// VPC Networks — pass-through fetcher (network_id = Mesh, tunnel_id = tunnel)
+	for (const vpc of config.vpc_networks ?? []) {
+		const networkId = vpc.network_id ?? vpc.tunnel_id
+		if (!networkId) {
+			throw new Error(`VPC Network "${vpc.binding}" requires either network_id or tunnel_id`)
+		}
+		console.log(`[lopata] VPC Network: ${vpc.binding} (${vpc.tunnel_id ? 'tunnel' : 'network'}: ${networkId})`)
+		env[vpc.binding] = instrumentBinding(new VpcNetworkBinding({ networkId, bindingName: vpc.binding }), {
+			type: 'vpc_network',
+			name: vpc.binding,
+			methods: ['fetch'],
+		})
+	}
+
+	// AI Search namespaces — proxy to the CF AI Search REST API
+	for (const ns of config.ai_search_namespaces ?? []) {
+		const accountId = (env.CLOUDFLARE_ACCOUNT_ID ?? process.env.CLOUDFLARE_ACCOUNT_ID) as string | undefined
+		const apiToken = (env.CLOUDFLARE_API_TOKEN ?? process.env.CLOUDFLARE_API_TOKEN) as string | undefined
+		console.log(`[lopata] AI Search namespace: ${ns.binding} (namespace: ${ns.namespace})`)
+		env[ns.binding] = instrumentBinding(new AiSearchNamespaceBinding(db, ns.namespace, accountId, apiToken), {
+			type: 'ai_search',
+			name: ns.binding,
+			methods: ['create', 'get', 'list', 'delete', 'search', 'chatCompletions'],
+		})
+	}
+
+	// Artifacts — control plane (SQLite + bare git repos); the git-over-HTTP endpoint
+	// is served by the dev server at /__artifacts/git/* (see cli/dev.ts).
+	for (const artifacts of config.artifacts ?? []) {
+		const remoteBase = (baseUrls?.artifacts ?? 'http://localhost:8787/__artifacts/git').replace(/\/$/, '')
+		console.log(`[lopata] Artifacts binding: ${artifacts.binding} (namespace: ${artifacts.namespace})`)
+		env[artifacts.binding] = instrumentBinding(
+			new ArtifactsBinding(db, artifacts.namespace, path.join(getDataDir(), 'artifacts'), remoteBase),
+			{ type: 'artifacts', name: artifacts.binding, methods: ['create', 'get', 'list', 'import', 'delete'] },
+		)
+	}
+
+	// Worker Loader — dynamic Workers (each its own Bun worker thread). Not wrapped in
+	// instrumentBinding: load()/get() return live WorkerStub handles *synchronously*, and
+	// the async span wrapper would turn them into Promises, breaking the
+	// `loader.get(id).getEntrypoint().fetch()` chaining the Cloudflare API requires.
+	for (const loader of config.worker_loaders ?? []) {
+		console.log(`[lopata] Worker Loader: ${loader.binding}`)
+		env[loader.binding] = new WorkerLoaderBinding(path.join(getDataDir(), 'worker-loader'))
+	}
+
+	// Flagship — SQLite-backed feature flags
+	if (config.flagship) {
+		console.log(`[lopata] Flagship binding: ${config.flagship.binding} (app: ${config.flagship.app_id})`)
+		env[config.flagship.binding] = instrumentBinding(new FlagshipBinding(db, config.flagship.app_id), {
+			type: 'flagship',
+			name: config.flagship.binding,
+			methods: [
+				'getBooleanValue',
+				'getStringValue',
+				'getNumberValue',
+				'getObjectValue',
+				'getBooleanValueDetails',
+				'getStringValueDetails',
+				'getNumberValueDetails',
+				'getObjectValueDetails',
+			],
+		})
+	}
+
 	// Version metadata binding
 	if (config.version_metadata) {
 		const binding = config.version_metadata.binding

package/src/generation-manager.ts

@@ -37,6 +37,7 @@ export class GenerationManager {
 	readonly cronEnabled: boolean
 	readonly executorFactory: DOExecutorFactory | undefined
 	readonly browserConfig: { wsEndpoint?: string; executablePath?: string; headless?: boolean } | undefined
+	readonly baseUrls: { artifacts?: string } | undefined
 	/** @internal Path to the wrangler config file (DO worker threads re-load it). */
 	_configPath: string = ''
 
@@ -51,6 +52,7 @@ export class GenerationManager {
 			executorFactory?: DOExecutorFactory
 			configPath?: string
 			browserConfig?: { wsEndpoint?: string; executablePath?: string; headless?: boolean }
+			baseUrls?: { artifacts?: string }
 		},
 	) {
 		this.config = config
@@ -62,6 +64,7 @@ export class GenerationManager {
 		this.cronEnabled = options?.cron ?? false
 		this.executorFactory = options?.executorFactory
 		this.browserConfig = options?.browserConfig
+		this.baseUrls = options?.baseUrls
 		this._configPath = options?.configPath ?? ''
 	}
 
@@ -104,7 +107,7 @@ export class GenerationManager {
 		// service bindings, email, browser, containers) live in main — the worker
 		// RPCs into them. Stateless ones duplicate in the thread. Static assets
 		// stay main-side for the auto-serve fallback.
-		const { env, registry } = buildEnv(this.config, this.baseDir, this.executorFactory, this.browserConfig, this._doNamespaces)
+		const { env, registry } = buildEnv(this.config, this.baseDir, this.executorFactory, this.browserConfig, this._doNamespaces, this.baseUrls)
 		wireServiceBindings(registry, {}, env, this.workerRegistry)
 
 		const executor = new WorkerThreadExecutor({
@@ -113,6 +116,7 @@ export class GenerationManager {
 			baseDir: this.baseDir,
 			workerName: this.workerName,
 			browserConfig: this.browserConfig,
+			artifactsBaseUrl: this.baseUrls?.artifacts,
 			mainEnv: env,
 		})
 		let readyInfo: WorkerReadyInfo

package/src/generation.ts

@@ -98,17 +98,34 @@ export class Generation {
 		try {
 			const assets = this.registry.staticAssets
 			let response: Response
-			if (!assets || this.config.assets?.binding) {
+			if (!assets) {
 				response = await this.threadExecutor.executeFetch(request)
 			} else {
+				// Cloudflare Static Assets are served FIRST for any existing asset,
+				// even when an `assets.binding` is configured — the binding only adds
+				// programmatic `env.ASSETS.fetch()` access, it does NOT make the worker
+				// own routing. The worker runs first ONLY for paths in `run_worker_first`
+				// (or when it's `true`). Some framework adapters (e.g. Astro's Cloudflare
+				// worker) greedily route-match catch-alls like `/[slug]` and 404 instead
+				// of delegating to ASSETS, so honoring assets-first here is required to
+				// match workerd — otherwise directory-index assets like `/account/`
+				// (served from `/account/index.html`) never reach the asset layer.
 				const workerFirst = shouldRunWorkerFirst(this.config.assets?.run_worker_first, url.pathname)
-				if (!workerFirst) {
+				// Cloudflare only serves static assets for GET/HEAD; every other
+				// method goes straight to the worker. WebSocket upgrades are GETs but
+				// must reach the worker's upgrade handler, so they're excluded too.
+				// Without this gate, assets-first routing would answer e.g.
+				// `POST /account/` with `/account/index.html` (200) and silently drop
+				// the write, or serve a colliding asset to a WS upgrade.
+				const isWebSocketUpgrade = request.headers.get('upgrade')?.toLowerCase() === 'websocket'
+				const canServeAssets = (request.method === 'GET' || request.method === 'HEAD') && !isWebSocketUpgrade
+				if (!workerFirst && canServeAssets) {
 					const assetResponse = await assets.fetch(request)
 					if (assetResponse.status !== 404) return assetResponse
 					response = await this.threadExecutor.executeFetch(request)
 				} else {
 					response = await this.threadExecutor.executeFetch(request)
-					if (response.status === 404) {
+					if (response.status === 404 && canServeAssets) {
 						// Drop the worker's streaming body so the source pump on the
 						// other side stops — we're discarding this response in favour
 						// of the assets fallback.

package/src/plugin.ts

@@ -1,4 +1,6 @@
 import { plugin } from 'bun'
+import type { Database } from 'bun:sqlite'
+import { buildAnalyticsEngineSqlResponse, isAnalyticsEngineSqlUrl, isLocalAnalyticsEngineToken } from './bindings/analytics-engine-sql'
 import type { ImageTransformOptions, OutputOptions } from './bindings/images'
 import { setupCloudflareGlobals } from './setup-globals'
 import { getActiveContext } from './tracing/context'
@@ -158,6 +160,41 @@ async function applyCfImageTransform(response: Response, imageOpts: Record<strin
 
 const _originalFetch = globalThis.fetch
 globalThis.fetch = ((input: any, init?: any): Promise<Response> => {
+	// Intercept the Cloudflare Analytics Engine SQL API (no Worker binding exists
+	// for reads) and serve it from the local SQLite store — same code runs in dev
+	// and prod unchanged.
+	const aeMethod = String(init?.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase()
+	const aeUrl = typeof input === 'string'
+		? input
+		: input instanceof URL
+		? input.href
+		: input instanceof Request
+		? input.url
+		: undefined
+	// Gate on the bearer token: missing or `Bearer local` is served locally; a real
+	// token falls through to the actual Cloudflare API (prod).
+	const aeAuth = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined)).get('authorization')
+	if (aeMethod === 'POST' && typeof aeUrl === 'string' && isAnalyticsEngineSqlUrl(aeUrl) && isLocalAnalyticsEngineToken(aeAuth)) {
+		// Set per worker-thread by buildThreadEnv / buildDoWorkerEnv before user code
+		// runs. Fail loudly rather than fall back to a possibly-wrong data dir, which
+		// would return plausible but incorrect numbers.
+		const db = (globalThis as { __lopata_db?: Database }).__lopata_db
+		if (!db) throw new Error('Analytics Engine SQL API was intercepted before the worker-thread database was wired')
+		const aeReq = new Request(input, init)
+		if (!getActiveContext()) return aeReq.text().then(sql => buildAnalyticsEngineSqlResponse(db, sql))
+		return startSpan({
+			name: 'analytics_engine sql',
+			kind: 'client',
+			attributes: { 'http.method': 'POST', 'http.url': aeUrl },
+		}, async () => {
+			const sql = (await aeReq.text()).trim()
+			if (sql) setSpanAttribute('db.statement', sql)
+			const res = buildAnalyticsEngineSqlResponse(db, sql)
+			setSpanAttribute('http.status_code', res.status)
+			return res
+		})
+	}
+
 	const ctx = getActiveContext()
 	if (ctx) {
 		ctx.fetchStack.current = new Error()

package/src/vite-plugin/dev-server-plugin.ts

@@ -923,12 +923,28 @@ function nodeStreamToReadable(stream: IncomingMessage): ReadableStream<Uint8Arra
 	})
 }
 
-async function writeResponse(response: Response, res: ServerResponse): Promise<void> {
+/**
+ * Convert Response headers to a node writeHead record. `set-cookie` must go
+ * through `getSetCookie()`: Headers iteration yields it once per cookie (and a
+ * keyed record would keep only the last one), so a multi-cookie response —
+ * e.g. better-auth's session_token + session_data — would silently lose
+ * cookies. Exported for tests.
+ */
+export function buildNodeHeaders(response: Response): Record<string, string | string[]> {
 	const headerRecord: Record<string, string | string[]> = {}
 	response.headers.forEach((value, key) => {
+		if (key.toLowerCase() === 'set-cookie') return
 		headerRecord[key] = value
 	})
-	res.writeHead(response.status, headerRecord)
+	const setCookies = response.headers.getSetCookie()
+	if (setCookies.length > 0) {
+		headerRecord['set-cookie'] = setCookies
+	}
+	return headerRecord
+}
+
+async function writeResponse(response: Response, res: ServerResponse): Promise<void> {
+	res.writeHead(response.status, buildNodeHeaders(response))
 
 	if (!response.body) {
 		res.end()

package/src/worker-thread/entry.ts

@@ -191,6 +191,7 @@ async function initRuntime(init: WorkerInitConfig) {
 		dataDir: init.dataDir,
 		rpc,
 		browserConfig: init.browserConfig,
+		artifactsBaseUrl: init.artifactsBaseUrl,
 		envWsBridge,
 	})
 	const { env } = built

package/src/worker-thread/executor.ts

@@ -49,6 +49,8 @@ export interface WorkerThreadExecutorOptions {
 	baseDir: string
 	workerName?: string
 	browserConfig?: { wsEndpoint?: string; executablePath?: string; headless?: boolean }
+	/** Base URL for the Artifacts git remote (main's `/__artifacts/git` endpoint). */
+	artifactsBaseUrl?: string
 	/** Main-thread env holding the stateful binding instances the worker calls into via RPC. */
 	mainEnv: Record<string, unknown>
 }
@@ -204,6 +206,7 @@ export class WorkerThreadExecutor {
 						dataDir: getDataDir(),
 						workerName: this._initConfig.workerName,
 						browserConfig: this._initConfig.browserConfig,
+						artifactsBaseUrl: this._initConfig.artifactsBaseUrl,
 					},
 				})
 				break

package/src/worker-thread/protocol.ts

@@ -152,6 +152,8 @@ export interface WorkerInitConfig {
 	workerName?: string
 	/** Browser Rendering local dev config (Chrome wsEndpoint or executable path). */
 	browserConfig?: { wsEndpoint?: string; executablePath?: string; headless?: boolean }
+	/** Base URL for the Artifacts git remote (main's `/__artifacts/git` endpoint). */
+	artifactsBaseUrl?: string
 }
 
 /** Names of the worker handlers we know how to invoke via RPC. */

package/src/worker-thread/thread-env.ts

@@ -10,11 +10,14 @@ import { Database } from 'bun:sqlite'
 import { existsSync, mkdirSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { AiBinding } from '../bindings/ai'
+import { AiSearchNamespaceBinding } from '../bindings/ai-search'
 import { SqliteAnalyticsEngine } from '../bindings/analytics-engine'
+import { ArtifactsBinding } from '../bindings/artifacts'
 import { BrowserBinding } from '../bindings/browser'
 import { openD1Database } from '../bindings/d1'
 import { DurableObjectIdImpl, hashIdFromName, randomUniqueIdHex } from '../bindings/durable-object'
 import { EmailMessage } from '../bindings/email'
+import { FlagshipBinding } from '../bindings/flagship'
 import { HyperdriveBinding } from '../bindings/hyperdrive'
 import { ImagesBinding } from '../bindings/images'
 import { SqliteKVNamespace } from '../bindings/kv'
@@ -23,7 +26,9 @@ import { FileR2Bucket } from '../bindings/r2'
 import { makeBindingProxy } from '../bindings/rpc-stub'
 import { serviceBindingConnectError } from '../bindings/service-binding'
 import { StaticAssets } from '../bindings/static-assets'
+import { VpcNetworkBinding } from '../bindings/vpc-network'
 import type { ResponseWithWebSocket } from '../bindings/websocket-pair'
+import { WorkerLoaderBinding } from '../bindings/worker-loader'
 import { SqliteWorkflowBinding } from '../bindings/workflow'
 import type { WranglerConfig } from '../config'
 import { runMigrations } from '../db'
@@ -47,6 +52,8 @@ export interface ThreadEnvOptions {
 	/** Guest-side bridge for WebSockets returned by env-binding fetches. */
 	envWsBridge: WsGuestBridge<WorkerMessage>
 	browserConfig?: { wsEndpoint?: string; executablePath?: string; headless?: boolean }
+	/** Base URL for the Artifacts git remote (main's `/__artifacts/git` endpoint). */
+	artifactsBaseUrl?: string
 }
 
 export interface ThreadEnvBuilt {
@@ -58,7 +65,7 @@ export interface ThreadEnvBuilt {
 	workflows: { bindingName: string; className: string; binding: SqliteWorkflowBinding }[]
 }
 
-export function buildThreadEnv({ config, baseDir, dataDir, rpc, envWsBridge, browserConfig }: ThreadEnvOptions): ThreadEnvBuilt {
+export function buildThreadEnv({ config, baseDir, dataDir, rpc, envWsBridge, browserConfig, artifactsBaseUrl }: ThreadEnvOptions): ThreadEnvBuilt {
 	mkdirSync(dataDir, { recursive: true })
 	mkdirSync(path.join(dataDir, 'r2'), { recursive: true })
 	mkdirSync(path.join(dataDir, 'd1'), { recursive: true })
@@ -67,6 +74,10 @@ export function buildThreadEnv({ config, baseDir, dataDir, rpc, envWsBridge, bro
 	db.run('PRAGMA journal_mode=WAL')
 	db.run('PRAGMA busy_timeout=5000')
 	runMigrations(db)
+	// Expose this thread's DB handle so the fetch patch (plugin.ts) can serve the
+	// intercepted Analytics Engine SQL API from the right data dir in multi-worker setups.
+	const threadGlobals = globalThis as { __lopata_db?: Database }
+	threadGlobals.__lopata_db = db
 
 	const env: Record<string, unknown> = {}
 
@@ -196,6 +207,66 @@ export function buildThreadEnv({ config, baseDir, dataDir, rpc, envWsBridge, bro
 		})
 	}
 
+	// VPC Networks — pass-through fetcher (network_id = Mesh, tunnel_id = tunnel)
+	for (const vpc of config.vpc_networks ?? []) {
+		const networkId = vpc.network_id ?? vpc.tunnel_id
+		if (!networkId) {
+			throw new Error(`VPC Network "${vpc.binding}" requires either network_id or tunnel_id`)
+		}
+		env[vpc.binding] = instrumentBinding(new VpcNetworkBinding({ networkId, bindingName: vpc.binding }), {
+			type: 'vpc_network',
+			name: vpc.binding,
+			methods: ['fetch'],
+		})
+	}
+
+	// AI Search namespaces — proxy to the CF AI Search REST API
+	for (const ns of config.ai_search_namespaces ?? []) {
+		const accountId = typeof env.CLOUDFLARE_ACCOUNT_ID === 'string' ? env.CLOUDFLARE_ACCOUNT_ID : process.env.CLOUDFLARE_ACCOUNT_ID
+		const apiToken = typeof env.CLOUDFLARE_API_TOKEN === 'string' ? env.CLOUDFLARE_API_TOKEN : process.env.CLOUDFLARE_API_TOKEN
+		env[ns.binding] = instrumentBinding(new AiSearchNamespaceBinding(db, ns.namespace, accountId, apiToken), {
+			type: 'ai_search',
+			name: ns.binding,
+			methods: ['create', 'get', 'list', 'delete', 'search', 'chatCompletions'],
+		})
+	}
+
+	// Artifacts — control plane (SQLite + bare git repos under dataDir/artifacts);
+	// the git-over-HTTP endpoint is served by main's Bun.serve at /__artifacts/git/*.
+	for (const artifacts of config.artifacts ?? []) {
+		const remoteBase = (artifactsBaseUrl ?? 'http://localhost:8787/__artifacts/git').replace(/\/$/, '')
+		env[artifacts.binding] = instrumentBinding(
+			new ArtifactsBinding(db, artifacts.namespace, path.join(dataDir, 'artifacts'), remoteBase),
+			{ type: 'artifacts', name: artifacts.binding, methods: ['create', 'get', 'list', 'import', 'delete'] },
+		)
+	}
+
+	// Worker Loader — dynamic Workers, each its own nested Bun worker thread. Not wrapped
+	// in instrumentBinding: load()/get() return live WorkerStub handles synchronously, and
+	// the async span wrapper would turn them into Promises (breaking the
+	// `loader.get(id).getEntrypoint().fetch()` chaining the Cloudflare API requires).
+	for (const loader of config.worker_loaders ?? []) {
+		env[loader.binding] = new WorkerLoaderBinding(path.join(dataDir, 'worker-loader'))
+	}
+
+	// Flagship — SQLite-backed feature flags
+	if (config.flagship) {
+		env[config.flagship.binding] = instrumentBinding(new FlagshipBinding(db, config.flagship.app_id), {
+			type: 'flagship',
+			name: config.flagship.binding,
+			methods: [
+				'getBooleanValue',
+				'getStringValue',
+				'getNumberValue',
+				'getObjectValue',
+				'getBooleanValueDetails',
+				'getStringValueDetails',
+				'getNumberValueDetails',
+				'getObjectValueDetails',
+			],
+		})
+	}
+
 	if (config.version_metadata) {
 		env[config.version_metadata.binding] = {
 			id: 'local-dev',