@supacloud/elysia 0.10.0 → 0.16.0

package/dist/persistent-command.d.ts

@@ -0,0 +1,20 @@
+import { type CommandIdentity, type DurableCommandReceipt } from "@supacloud/contracts";
+import { type CommandInvocation } from "./index";
+export interface PersistentCommandHandler<Result> {
+    readonly kind: "transactional" | "external";
+    execute(identity: CommandIdentity, key: string, value: unknown): Promise<DurableCommandReceipt<Result>>;
+}
+/** Registered persistence owns the operation; a second route handler is never invoked. */
+export declare function createPersistentCommandAdapter<Result>(command: PersistentCommandHandler<Result>, options: {
+    /** Resolve verified tenant/actor identity from the host, never from request body. */
+    identity(invocation: CommandInvocation): CommandIdentity | Promise<CommandIdentity>;
+    input(invocation: CommandInvocation): unknown;
+}): {
+    capabilities: {
+        audit: boolean;
+        idempotency: boolean;
+        transaction: boolean;
+        boundary: "external" | "database";
+    };
+    execute(invocation: CommandInvocation): Promise<DurableCommandReceipt<Result>>;
+};

package/dist/schema_contract.d.ts

@@ -0,0 +1,160 @@
+import { StatusMap, ElysiaCustomStatusResponse, type Cookie, type Elysia, type HTTPMethod, type InputSchema, type MaybePromise, type TSchema, type UnwrapSchema } from "elysia";
+import type { ResponseMapSelector as AppResponseMapSelector, RouteContractSchemas as AppRouteContractSchemas } from "@supacloud/app";
+/** Response selectors are owned by @supacloud/app and re-exported by the adapter. */
+export type ResponseMapSelector = AppResponseMapSelector;
+/** The schema fields shared by Elysia routes, generated clients and docs. */
+export type RouteContractSchemas = AppRouteContractSchemas;
+/**
+ * Response selectors supported by the shared contract. Numeric selectors are
+ * represented as both numbers and numeric strings at runtime; the latter are
+ * useful when contracts are loaded from JSON or generated source.
+ */
+type StatusDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type StatusFamily = 1 | 2 | 3 | 4 | 5;
+type StatusCodeForFamily<Family extends StatusFamily> = `${Family}${StatusDigit}${StatusDigit}` extends infer Value ? Value extends `${infer Code extends number}` ? Code : never : never;
+type AllHttpStatusCodes = StatusCodeForFamily<StatusFamily>;
+type KeyMatchingLower<Value, Target extends string> = {
+    [Key in keyof Value & string]: Lowercase<Key> extends Target ? Key : never;
+}[keyof Value & string];
+type ExactResponseKey<Value, Code extends number> = Code extends keyof Value ? Code : `${Code}` extends keyof Value ? `${Code}` : never;
+type FamilyResponseKey<Value, Code extends number> = `${Code}` extends `${infer Family extends StatusFamily}${StatusDigit}${StatusDigit}` ? KeyMatchingLower<Value, `${Family}xx`> : never;
+type DefaultResponseKey<Value> = KeyMatchingLower<Value, "default">;
+type HasExactResponseKey<Value, Code extends number> = [
+    ExactResponseKey<Value, Code>
+] extends [never] ? false : true;
+type HasFamilyResponseKey<Value, Family extends StatusFamily> = [
+    KeyMatchingLower<Value, `${Family}xx`>
+] extends [never] ? false : true;
+type AllowsPlainSuccessResponse<Value> = HasExactResponseKey<Value, 200> extends true ? true : HasFamilyResponseKey<Value, 2> extends true ? true : [DefaultResponseKey<Value>] extends [never] ? false : true;
+type ResponseSchemaForCode<Value, Code extends number> = ExactResponseKey<Value, Code> extends infer Exact ? [Exact] extends [never] ? FamilyResponseKey<Value, Code> extends infer Family ? [Family] extends [never] ? DefaultResponseKey<Value> extends infer Default ? [Default] extends [never] ? never : Default extends keyof Value ? Value[Default] : never : never : Family extends keyof Value ? Value[Family] : never : never : Exact extends keyof Value ? Value[Exact] : never : never;
+type DeclaredResponses<Schemas extends RouteContractSchemas> = "responses" extends keyof Schemas ? NonNullable<Schemas["responses"]> : never;
+type LegacyResponse<Schemas extends RouteContractSchemas> = "response" extends keyof Schemas ? NonNullable<Schemas["response"]> : never;
+type ResponseField<Schemas extends RouteContractSchemas> = [
+    DeclaredResponses<Schemas>
+] extends [never] ? [LegacyResponse<Schemas>] extends [never] ? undefined : LegacyResponse<Schemas> : DeclaredResponses<Schemas>;
+type NumericResponseCodes<Value> = Value extends Readonly<Record<string | number, unknown>> ? {
+    [Key in keyof Value]: Key extends number ? Key : Key extends `${infer Numeric extends number}` ? Numeric : never;
+}[keyof Value] : never;
+type FamilyResponseCodes<Value> = Value extends Readonly<Record<string | number, unknown>> ? {
+    [Key in keyof Value & string]: Lowercase<Key> extends `${infer Family extends StatusFamily}xx` ? StatusCodeForFamily<Family> : never;
+}[keyof Value & string] : never;
+type ResponseStatusCodes<Value> = NumericResponseCodes<Value> | FamilyResponseCodes<Value> | ([DefaultResponseKey<Value>] extends [never] ? never : AllHttpStatusCodes);
+type DecodedSchema<Value> = Value extends TSchema ? UnwrapSchema<Value> : unknown;
+type DecodedResponse<Schemas extends RouteContractSchemas> = ResponseField<Schemas> extends infer Response ? Response extends TSchema ? DecodedSchema<Response> : Response extends Readonly<Record<string | number, unknown>> ? DecodedSchema<Response[keyof Response]> : DecodedSchema<Response> : unknown;
+type StatusResponse<Schemas extends RouteContractSchemas> = ResponseField<Schemas> extends infer Response ? Response extends TSchema ? never : Response extends Readonly<Record<string | number, unknown>> ? {
+    [Code in ResponseStatusCodes<Response>]: ElysiaCustomStatusResponse<Code, DecodedSchema<ResponseSchemaForCode<Response, Code>>>;
+}[ResponseStatusCodes<Response>] : never : never;
+/**
+ * A plain handler return is sent as the default HTTP 200 response.  When a
+ * status map declares several payloads, only the schema selected for 200 is
+ * valid here; every other payload must use `status(code, value)` so its
+ * status and schema stay coupled at runtime.
+ */
+type PlainResponse<Schemas extends RouteContractSchemas> = ResponseField<Schemas> extends infer Response ? Response extends Readonly<Record<string | number, unknown>> ? AllowsPlainSuccessResponse<Response> extends true ? DecodedSchema<ResponseSchemaForCode<Response, 200>> : never : DecodedResponse<Schemas> : never;
+type ElysiaRouteOutput<Schemas extends RouteContractSchemas> = PlainResponse<Schemas> | StatusResponse<Schemas> | Response | void;
+/** Raw schema shape consumed by Elysia's route registration API. */
+export interface ElysiaRouteSchema<Schemas extends RouteContractSchemas> {
+    body?: Schemas["body"] extends TSchema ? Schemas["body"] : undefined;
+    params?: Schemas["params"] extends TSchema ? Schemas["params"] : undefined;
+    query?: Schemas["query"] extends TSchema ? Schemas["query"] : undefined;
+    headers?: Schemas["headers"] extends TSchema ? Schemas["headers"] : undefined;
+    cookie?: Schemas["cookie"] extends TSchema ? Schemas["cookie"] : undefined;
+    response?: ResponseField<Schemas>;
+}
+type PathParameterNames<Path extends string> = Path extends `${string}:${infer Name}/${infer Rest}` ? Name | PathParameterNames<`/${Rest}`> : Path extends `${string}:${infer Name}` ? Name : never;
+type PathParameters<Path extends string> = [PathParameterNames<Path>] extends [never] ? Record<string, string> : {
+    [Name in PathParameterNames<Path>]: string;
+};
+type DecodedField<Schemas extends RouteContractSchemas, Key extends keyof RouteContractSchemas> = [
+    Extract<Schemas[Key], TSchema>
+] extends [never] ? unknown : UnwrapSchema<Extract<Schemas[Key], TSchema>>;
+type DecodedCookie<Schemas extends RouteContractSchemas> = DecodedField<Schemas, "cookie"> extends infer Value ? Value extends Record<string, unknown> ? Record<string, Cookie<unknown>> & {
+    [Key in keyof Value]-?: Cookie<Value[Key]>;
+} : Record<string, Cookie<unknown>> : Record<string, Cookie<unknown>>;
+type StatusCode<Schemas extends RouteContractSchemas> = ResponseField<Schemas> extends infer Response ? Response extends TSchema ? never : Response extends Readonly<Record<string | number, unknown>> ? ResponseStatusCodes<Response> : never : never;
+type StatusResponseValue<Schemas extends RouteContractSchemas, Code extends number> = ResponseField<Schemas> extends infer Response ? Response extends TSchema ? DecodedSchema<Response> : Response extends Readonly<Record<string | number, unknown>> ? DecodedSchema<ResponseSchemaForCode<Response, Code>> : DecodedSchema<Response> : unknown;
+type RouteStatus<Schemas extends RouteContractSchemas> = [StatusCode<Schemas>] extends [never] ? <const Code extends number, const Value>(code: Code, response: Value) => ElysiaCustomStatusResponse<Code, Value> : <const Code extends StatusCode<Schemas>, const Value extends StatusResponseValue<Schemas, Code>>(code: Code, response: Value) => ElysiaCustomStatusResponse<Code, Value>;
+/** Elysia-compatible decoded context inferred from one route contract and path. */
+export type ElysiaRouteContext<Schemas extends RouteContractSchemas, Path extends string = ""> = {
+    body: DecodedField<Schemas, "body">;
+    params: Schemas["params"] extends TSchema ? DecodedField<Schemas, "params"> : PathParameters<Path>;
+    query: Schemas["query"] extends TSchema ? DecodedField<Schemas, "query"> : Record<string, string>;
+    headers: Schemas["headers"] extends TSchema ? DecodedField<Schemas, "headers"> : Record<string, string | undefined>;
+    cookie: DecodedCookie<Schemas>;
+    request: Request;
+    path: string;
+    route: Path;
+    server: unknown;
+    store: Record<string, unknown>;
+    set: {
+        headers: Record<string, string>;
+        status?: number | keyof StatusMap;
+        redirect?: string;
+        cookie?: Record<string, unknown>;
+    };
+    status: RouteStatus<Schemas>;
+    redirect: (url: string, status?: number) => Response;
+};
+/** Handler type with Elysia's native decoded context and status-aware return type. */
+export type ElysiaRouteHandler<Schemas extends RouteContractSchemas, Path extends string = ""> = (context: ElysiaRouteContext<Schemas, Path>) => MaybePromise<ElysiaRouteOutput<Schemas>>;
+export interface ElysiaRouteDefinition<Method extends HTTPMethod, Path extends string, Schemas extends RouteContractSchemas> {
+    readonly method: Method;
+    readonly path: Path;
+    readonly contract: Readonly<Schemas>;
+    readonly handler: ElysiaRouteHandler<Schemas, Path>;
+}
+/**
+ * Keeps route schemas in one immutable value that can be reused by the
+ * compiler, generated clients and the Elysia route helper.
+ */
+export declare function defineRouteContract<const Schemas extends RouteContractSchemas>(schemas: Schemas): Readonly<Schemas>;
+/** Select the response schema using exact status > family > default precedence. */
+export declare function responseSchemaForStatus(responses: Readonly<Record<string | number, unknown>>, status: number): unknown | undefined;
+export declare function responseStatusDeclared(responses: Readonly<Record<string | number, unknown>>, status: number): boolean;
+export declare function responseStatusOf(value: unknown, configuredStatus: number | string | undefined): number;
+export declare function assertResponseStatusDeclared(responses: Readonly<Record<string | number, unknown>>, status: number): void;
+/** Convert the shared contract shape to Elysia's `response` route option. */
+export declare function toElysiaRouteSchema<const Schemas extends RouteContractSchemas>(contract: Schemas): InputSchema<never>;
+/**
+ * Binds a shared contract to an Elysia-native handler. The handler callback is
+ * contextually typed from the same schemas that will be registered at runtime.
+ */
+export declare function defineElysiaRoute<const Method extends HTTPMethod, const Path extends string, const Schemas extends RouteContractSchemas>(method: Method, path: Path, contract: Schemas, handler: ElysiaRouteHandler<NoInfer<Schemas>, Path>): ElysiaRouteDefinition<Method, Path, Schemas>;
+/** Register a contract-bound route while preserving Elysia's fluent app API. */
+export declare function registerElysiaRoute<const App extends Elysia, const Method extends HTTPMethod, const Path extends string, const Schemas extends RouteContractSchemas>(app: App, route: ElysiaRouteDefinition<Method, Path, Schemas>): App;
+export declare class SchemaContractError extends Error {
+    readonly code = "SCHEMA_CONTRACT_INVALID";
+    constructor();
+}
+/** Shares Elysia's validation and transformation semantics without trusting a caller-supplied result type. */
+export type SchemaNormalizeMode = boolean | "exactMirror" | "typebox";
+export interface SchemaDecoderOptions {
+    /** Match Elysia's default route normalization unless explicitly disabled. */
+    normalize?: SchemaNormalizeMode;
+    /** Query/path coercion is opt-in because body and job payloads are normally typed JSON. */
+    coerce?: boolean;
+}
+export declare function createSchemaDecoder<const Schema extends TSchema>(schema: Schema, options?: SchemaDecoderOptions): (value: unknown) => UnwrapSchema<Schema>;
+/**
+ * The body and response schemas are also route options. The decoder fields
+ * structurally implement @supacloud/app's HttpContract without a runtime import.
+ */
+export declare function defineJsonContract<const Input extends TSchema, const Result extends TSchema>(schemas: {
+    body: Input;
+    response: Result;
+}, request: (input: NoInfer<UnwrapSchema<Input>>) => {
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    url: string;
+    body?: unknown;
+}, options?: SchemaDecoderOptions): Readonly<{
+    input: (value: unknown) => UnwrapSchema<Input, {}>;
+    result: (value: unknown) => UnwrapSchema<Result, {}>;
+    request: (input: NoInfer<UnwrapSchema<Input>>) => {
+        method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+        url: string;
+        body?: unknown;
+    };
+    body: Input;
+    response: Result;
+}>;
+export {};

package/dist/webhook-migration-example.d.ts

@@ -0,0 +1,41 @@
+import type { CommandAuthorization, CommandIdentity } from "@supacloud/contracts";
+import { type CommandDatabase, type CommandTransaction } from "@supacloud/db";
+export { decodeWebhookInput } from "./fixtures/webhook/contracts";
+export declare const WEBHOOK_EXAMPLE_SQL = "CREATE TABLE IF NOT EXISTS public.webhook_module_example (\n  tenant_id text NOT NULL, id text NOT NULL, enabled boolean NOT NULL,\n  writes integer NOT NULL DEFAULT 0, PRIMARY KEY (tenant_id,id)\n);";
+/** Composition only; the compiler generates factories and routes from the real module. */
+export declare function createWebhookMigrationExample(options: {
+    database: CommandDatabase;
+    authenticate(request: Request): Promise<CommandIdentity>;
+    authorize(identity: CommandIdentity, transaction: CommandTransaction): Promise<CommandAuthorization>;
+    writeAudit?(transaction: CommandTransaction): Promise<void>;
+}): {
+    app: import("elysia").default<"", {
+        decorator: {};
+        store: {};
+        derive: {};
+        resolve: {};
+    }, {
+        typebox: {};
+        error: {};
+    }, {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {};
+    }, {}, {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    }, {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    }>;
+    modules: import("./fixtures/webhook-generated/application").CompiledModule[];
+};

package/dist/worker.d.ts

@@ -0,0 +1,150 @@
+import { type CompiledJob, type CompiledModule, type ExecutionObserver, type JobExecutor } from "./index";
+export type WorkerState = "idle" | "starting" | "running" | "stopping" | "stopped";
+/** The transport-specific claim is mapped to this small execution contract. */
+export interface WorkerClaim {
+    id: string;
+    jobName: string;
+    input: unknown;
+    attempt?: number;
+    requestContext?: unknown;
+}
+export interface WorkerReceiptContext {
+    readonly jobId: string;
+    readonly jobName: string;
+    readonly attempt: number;
+    readonly signal: AbortSignal;
+}
+export type WorkerAcknowledge<TClaim, TReceipt> = (claim: TClaim, output: unknown, context: WorkerReceiptContext) => TReceipt | Promise<TReceipt>;
+export type WorkerFail<TClaim, TReceipt> = (claim: TClaim, error: unknown, context: WorkerReceiptContext) => TReceipt | Promise<TReceipt>;
+/** Minimal queue message shape shared by the public SupaCloud queue client. */
+export interface WorkerQueueMessage {
+    id: string | number;
+    payload: unknown;
+}
+export interface WorkerQueueReceiveOptions {
+    visibilityTimeoutSec?: number;
+    sleepSeconds?: number;
+    sleep_seconds?: number;
+}
+export interface WorkerQueueFailureOptions {
+    error?: string;
+    deadLetter?: boolean;
+}
+/** Structural port implemented by `client.queue(name)` without a package dependency. */
+export interface WorkerQueuePort<TMessage extends WorkerQueueMessage = WorkerQueueMessage, TReceipt = unknown> {
+    receive(options?: WorkerQueueReceiveOptions): Promise<TMessage | null>;
+    ack(messageId: string | number): TReceipt | Promise<TReceipt>;
+    fail(messageId: string | number, options?: WorkerQueueFailureOptions): TReceipt | Promise<TReceipt>;
+}
+export interface QueueWorkerTransportOptions<TMessage extends WorkerQueueMessage, TClaim, TReceipt> {
+    queue: WorkerQueuePort<TMessage, TReceipt>;
+    decodeClaim: (message: TMessage) => TClaim;
+    messageId: (claim: TClaim) => string | number;
+    receive?: WorkerQueueReceiveOptions;
+}
+/**
+ * Adapts the existing SupaCloud queue client to the worker transport contract.
+ * Queue leasing and retry policy remain owned by the queue implementation.
+ */
+export declare function createQueueWorkerTransport<TMessage extends WorkerQueueMessage, TClaim, TReceipt>(options: QueueWorkerTransportOptions<TMessage, TClaim, TReceipt>): WorkerTransport<TClaim, TReceipt>;
+/**
+ * Queue/task ownership stays in the host adapter. The worker never interprets
+ * a receipt and therefore supports platform-specific receipt types unchanged.
+ */
+export interface WorkerTransport<TClaim = WorkerClaim, TReceipt = unknown> {
+    claim(signal: AbortSignal): Promise<TClaim | null>;
+    /** Preferred spelling. */
+    ack?: WorkerAcknowledge<TClaim, TReceipt>;
+    /** Compatibility spelling for adapters that use the full verb. */
+    acknowledge?: WorkerAcknowledge<TClaim, TReceipt>;
+    fail: WorkerFail<TClaim, TReceipt>;
+}
+export interface WorkerRunResult<TReceipt> {
+    claimId: string;
+    jobName: string;
+    status: "acknowledged" | "failed";
+    receipt: TReceipt;
+}
+export interface WorkerOptions<TClaim = WorkerClaim, TReceipt = unknown> {
+    modules?: readonly CompiledModule[];
+    deps?: Record<string, unknown>;
+    transport: WorkerTransport<TClaim, TReceipt>;
+    /** Convert a platform claim into the framework's stable execution shape. */
+    mapClaim?: (claim: TClaim) => WorkerClaim;
+    /** Build a request-like context for the Job. */
+    requestContext?: (claim: WorkerClaim, signal: AbortSignal) => unknown | Promise<unknown>;
+    workerId?: string;
+    concurrency?: number;
+    pollIntervalMs?: number;
+    executor?: JobExecutor;
+    onExecution?: ExecutionObserver;
+    onError?: (error: unknown) => void | Promise<void>;
+    /** Optional application-service cleanup owned by the host/bootstrap. */
+    destroyServices?: (services: Record<string, unknown>, imported: Record<string, Record<string, unknown>>) => void | Promise<void>;
+}
+export declare class WorkerRegistrationError extends Error {
+    readonly code: "WORKER_DUPLICATE_JOB" | "WORKER_DUPLICATE_MODULE" | "WORKER_INVALID_JOB" | "WORKER_TRANSPORT_INVALID" | "WORKER_NOT_STARTED";
+    constructor(code: WorkerRegistrationError["code"], message: string);
+}
+export type WorkerReceiptOperation = "ack" | "fail";
+/** A platform settlement may have applied even when its response was lost. */
+export declare class WorkerReceiptUnconfirmedError extends Error {
+    readonly operation: WorkerReceiptOperation;
+    readonly claimId: string;
+    readonly code: "WORKER_RECEIPT_UNCONFIRMED";
+    readonly mutationMayHaveApplied: true;
+    constructor(operation: WorkerReceiptOperation, claimId: string);
+}
+/**
+ * Registers compiler-emitted Jobs and drives an existing claim/receipt
+ * transport. It deliberately does not implement queue leasing, retries, or
+ * DLQ policy; those are properties of the platform adapter.
+ */
+export declare class SupaCloudWorker<TClaim = WorkerClaim, TReceipt = unknown> {
+    private readonly registry;
+    private readonly modules;
+    private readonly moduleServices;
+    private readonly deps;
+    private readonly transport;
+    private readonly mapClaim;
+    private readonly requestContextFactory;
+    private readonly workerId;
+    private readonly concurrency;
+    private readonly pollIntervalMs;
+    private readonly executor;
+    private readonly observer;
+    private readonly onError;
+    private readonly destroyServices;
+    private stateValue;
+    private claimController;
+    private loopPromise;
+    private startPromise;
+    private stopPromise;
+    private stopRequested;
+    private readonly inFlight;
+    private services;
+    private imported;
+    constructor(options: WorkerOptions<TClaim, TReceipt>);
+    get state(): WorkerState;
+    get id(): string;
+    get jobNames(): readonly string[];
+    get jobs(): readonly CompiledJob[];
+    /** Register a compiled module before the worker starts. */
+    registerModule(module: CompiledModule): void;
+    /** Alias useful for hosts that register generated modules incrementally. */
+    register(module: CompiledModule): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Claim and process one item, primarily useful for deterministic hosts/tests. */
+    runOnce(): Promise<WorkerRunResult<TReceipt> | null>;
+    /** Process a host-provided claim without performing another claim operation. */
+    processClaim(rawClaim: TClaim): Promise<WorkerRunResult<TReceipt>>;
+    private failClaim;
+    private initialize;
+    private releaseServices;
+    private pollLoop;
+    private reportError;
+    private capturePositiveInteger;
+    private captureNonNegativeInteger;
+}
+export declare function createWorker<TClaim = WorkerClaim, TReceipt = unknown>(options: WorkerOptions<TClaim, TReceipt>): SupaCloudWorker<TClaim, TReceipt>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/elysia",
-  "version": "0.10.0",
+  "version": "0.16.0",
   "description": "Elysia runtime adapter for SupaCloud compiled modules: application/request scopes, route registration and validation",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,15 +15,20 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "compatibility.json"
   ],
   "scripts": {
+    "generate:example": "bun src/generate-webhook-example.ts",
     "build": "bun run clean && bun run build:js && bun run build:types",
-    "build:js": "bun build src/index.ts --outdir dist --target node --external elysia --external jose",
+    "build:js": "bun build src/index.ts --outdir dist --target node --external elysia --external jose --external @supacloud/app --external @supacloud/db --external @supacloud/contracts",
     "build:types": "tsc -p tsconfig.json --emitDeclarationOnly",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run build",
     "test": "bun test",
+    "test:conformance": "bun test src/conformance.test.ts",
+    "test:runtime-safety": "SUPACLOUD_REQUIRE_RUNTIME_SAFETY=1 bun test src/runtime-safety.test.ts",
+    "test:contract-upgrade": "bun test src/contract-upgrade.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "typecheck:test": "tsc -p tsconfig.test.json --noEmit"
   },
@@ -41,13 +46,22 @@
     "directory": "packages/elysia"
   },
   "dependencies": {
+    "@supacloud/app": "0.14.0",
+    "@supacloud/contracts": "0.4.0",
     "jose": "^6.2.11"
   },
+  "overrides": {
+    "@supacloud/contracts": "0.4.0",
+    "@supacloud/commands": "0.4.0"
+  },
   "peerDependencies": {
     "elysia": "^1.4.30"
   },
   "devDependencies": {
-    "@types/bun": "^1.4.0",
+    "@supacloud/compiler": "0.21.0",
+    "@supacloud/commands": "0.4.0",
+    "@supacloud/db": "0.7.1",
+    "@types/bun": "^1.4.2",
     "elysia": "^1.4.30",
     "typescript": "^7.0.2"
   }