feat: add @objectql/edge-adapter foundation package

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/foundation/edge-adapter/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@objectql/edge-adapter",
+  "version": "4.2.0",
+  "description": "Edge runtime adapter for ObjectQL - runtime detection, capability validation, and driver binding resolution",
+  "keywords": [
+    "objectql",
+    "edge",
+    "runtime",
+    "cloudflare",
+    "deno",
+    "vercel",
+    "adapter"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@objectql/types": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.4"
+  }
+}

packages/foundation/edge-adapter/src/binding-resolver.ts

@@ -0,0 +1,68 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { EdgeAdapterConfig, EdgeRuntime } from '@objectql/types';
+
+/**
+ * Default driver recommendations per runtime.
+ */
+const DEFAULT_BINDINGS: Readonly<Record<EdgeRuntime, string>> = {
+    'cloudflare-workers': '@objectql/driver-sqlite-wasm',
+    'deno-deploy': '@objectql/driver-pg-wasm',
+    'vercel-edge': '@objectql/driver-memory',
+    'bun': '@objectql/driver-sqlite-wasm',
+    'node': '@objectql/driver-sql',
+};
+
+/**
+ * A fully resolved driver binding for a named datasource.
+ */
+export interface ResolvedBinding {
+    readonly datasource: string;
+    readonly driver: string;
+    readonly binding?: string;
+    readonly config: Record<string, unknown>;
+}
+
+/**
+ * Returns the recommended default driver for a given runtime.
+ */
+export function getDefaultDriver(runtime: EdgeRuntime): string {
+    return DEFAULT_BINDINGS[runtime];
+}
+
+/**
+ * Resolves edge driver bindings from adapter configuration.
+ *
+ * If no explicit bindings are provided, a default binding is generated
+ * using the recommended driver for the target runtime.
+ */
+export function resolveBindings(config: EdgeAdapterConfig): readonly ResolvedBinding[] {
+    const bindings = config.bindings ?? {};
+    const resolved: ResolvedBinding[] = [];
+
+    for (const [datasource, binding] of Object.entries(bindings)) {
+        resolved.push({
+            datasource,
+            driver: binding.driver,
+            binding: binding.binding,
+            config: binding.config ?? {},
+        });
+    }
+
+    // If no bindings provided, resolve a default
+    if (resolved.length === 0) {
+        resolved.push({
+            datasource: 'default',
+            driver: getDefaultDriver(config.runtime),
+            config: {},
+        });
+    }
+
+    return resolved;
+}

packages/foundation/edge-adapter/src/capabilities.ts

@@ -0,0 +1,79 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { EdgeCapabilities, EdgeRuntime } from '@objectql/types';
+import { EDGE_CAPABILITIES } from '@objectql/types';
+
+/**
+ * Declares the minimum capabilities a runtime must provide.
+ */
+export interface CapabilityRequirement {
+    readonly wasm?: boolean;
+    readonly persistentStorage?: boolean;
+    readonly webSocket?: boolean;
+    readonly scheduledTriggers?: boolean;
+    readonly minExecutionTime?: number;
+}
+
+/**
+ * Result of validating a runtime against a set of requirements.
+ */
+export interface CapabilityValidationResult {
+    readonly valid: boolean;
+    readonly runtime: EdgeRuntime;
+    readonly capabilities: EdgeCapabilities;
+    readonly missing: readonly string[];
+}
+
+/**
+ * Returns the predefined capability profile for a given runtime.
+ */
+export function getCapabilities(runtime: EdgeRuntime): EdgeCapabilities {
+    return EDGE_CAPABILITIES[runtime];
+}
+
+/**
+ * Validates that a runtime satisfies the given capability requirements.
+ */
+export function validateCapabilities(
+    runtime: EdgeRuntime,
+    requirements: CapabilityRequirement,
+): CapabilityValidationResult {
+    const capabilities = getCapabilities(runtime);
+    const missing: string[] = [];
+
+    if (requirements.wasm && !capabilities.wasm) {
+        missing.push('WebAssembly');
+    }
+    if (requirements.persistentStorage && !capabilities.persistentStorage) {
+        missing.push('Persistent Storage');
+    }
+    if (requirements.webSocket && !capabilities.webSocket) {
+        missing.push('WebSocket');
+    }
+    if (requirements.scheduledTriggers && !capabilities.scheduledTriggers) {
+        missing.push('Scheduled Triggers');
+    }
+    if (
+        requirements.minExecutionTime &&
+        capabilities.maxExecutionTime !== undefined &&
+        capabilities.maxExecutionTime !== Infinity &&
+        capabilities.maxExecutionTime < requirements.minExecutionTime
+    ) {
+        missing.push(
+            `Execution time (need ${requirements.minExecutionTime}ms, max ${capabilities.maxExecutionTime}ms)`,
+        );
+    }
+
+    return {
+        valid: missing.length === 0,
+        runtime,
+        capabilities,
+        missing,
+    };
+}

packages/foundation/edge-adapter/src/detector.ts

@@ -0,0 +1,44 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { EdgeRuntime } from '@objectql/types';
+
+/**
+ * Detects the current edge runtime environment by inspecting global objects.
+ *
+ * Detection order matters — more specific checks come first to avoid
+ * false positives (e.g., Cloudflare Workers before generic edge checks).
+ */
+export function detectRuntime(): EdgeRuntime {
+    // Check for Cloudflare Workers (has WebSocketPair in global scope)
+    if (
+        typeof globalThis !== 'undefined' &&
+        'caches' in globalThis &&
+        typeof (globalThis as Record<string, unknown>).WebSocketPair !== 'undefined'
+    ) {
+        return 'cloudflare-workers';
+    }
+
+    // Check for Deno
+    if (typeof (globalThis as Record<string, unknown>).Deno !== 'undefined') {
+        return 'deno-deploy';
+    }
+
+    // Check for Bun
+    if (typeof (globalThis as Record<string, unknown>).Bun !== 'undefined') {
+        return 'bun';
+    }
+
+    // Check for Vercel Edge Runtime
+    if (typeof (globalThis as Record<string, unknown>).EdgeRuntime !== 'undefined') {
+        return 'vercel-edge';
+    }
+
+    // Default to Node.js
+    return 'node';
+}