rwsdk 0.1.8 → 0.1.10

package/bin/rwsync

@@ -1,2 +1,12 @@
 #!/bin/sh
-DIR=$PWD && (cd "${@:-$RWSDK_REPO}/sdk" && pnpm debug:sync $DIR)
+set -e
+
+# This script is a lightweight wrapper that passes all arguments to the underlying
+# debug:sync Node.js script.
+# The RWSDK_REPO env var should point to the root of the sdk repo.
+
+# Capture the current directory *before* changing it
+TARGET_DIR=$PWD
+
+cd "${RWSDK_REPO}/sdk"
+pnpm debug:sync "$TARGET_DIR" "$@"

package/dist/runtime/lib/db/typeInference/assert.d.ts

@@ -0,0 +1,2 @@
+export type AssertStillImplements<OurBuilder, KyselyBuilder> = keyof KyselyBuilder extends keyof OurBuilder ? true : false;
+export type Assert<T extends true> = T;

package/dist/runtime/lib/db/typeInference/assert.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/builders/alterColumn.d.ts

@@ -1,12 +1,27 @@
-export interface AlterColumnBuilder {
-    setDataType<T extends string>(dataType: T): AlteredColumnBuilder<"setDataType", T>;
-    setDefault<T>(value: T): AlteredColumnBuilder<"setDefault", T>;
-    dropDefault(): AlteredColumnBuilder<"dropDefault", true>;
-    setNotNull(): AlteredColumnBuilder<"setNotNull", true>;
-    dropNotNull(): AlteredColumnBuilder<"dropNotNull", true>;
+import { AlterColumnNode } from "kysely";
+import { Alteration } from "../utils";
+export interface AlteredColumnBuilder<TAlteration extends Alteration> {
+    readonly __alteration: TAlteration;
+    toOperationNode(): AlterColumnNode;
 }
-export interface AlteredColumnBuilder<Kind extends string, Value> {
-    readonly kind: Kind;
-    readonly value: Value;
+export interface AlterColumnBuilder {
+    setDataType<T extends string>(dataType: T): AlteredColumnBuilder<{
+        kind: "setDataType";
+        dataType: T;
+    }>;
+    setDefault<T>(value: T): AlteredColumnBuilder<{
+        kind: "setDefault";
+        value: T;
+    }>;
+    dropDefault(): AlteredColumnBuilder<{
+        kind: "dropDefault";
+    }>;
+    setNotNull(): AlteredColumnBuilder<{
+        kind: "setNotNull";
+    }>;
+    dropNotNull(): AlteredColumnBuilder<{
+        kind: "dropNotNull";
+    }>;
+    $call<T>(func: (qb: this) => T): T;
 }
-export type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder<any, any>;
+export type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder<any>;

package/dist/runtime/lib/db/typeInference/builders/alterTable.d.ts

@@ -1,21 +1,53 @@
-import { SqlToTsType, ExecutedBuilder, Prettify } from "../utils";
+import { SqlToTsType, ExecutedBuilder, AlterOperation, AddColumnOp, DropColumnOp, RenameColumnOp, AlterColumnOp, ModifyColumnOp } from "../utils";
 import { ColumnDefinitionBuilder } from "./columnDefinition";
 import { AlterColumnBuilderCallback } from "./alterColumn";
-export interface AlterTableBuilder<TName extends string, TSchema extends Record<string, any> = {}> {
+import { ForeignKeyConstraintBuilder, Expression, CheckConstraintNode, UniqueConstraintNode, PrimaryKeyConstraintNode, sql } from "kysely";
+type DataTypeExpression = string | typeof sql;
+interface CheckConstraintBuilder {
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): CheckConstraintNode;
+}
+interface UniqueConstraintBuilder {
+    nullsNotDistinct(): UniqueConstraintBuilder;
+    deferrable(): UniqueConstraintBuilder;
+    notDeferrable(): UniqueConstraintBuilder;
+    initiallyDeferred(): UniqueConstraintBuilder;
+    initiallyImmediate(): UniqueConstraintBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): UniqueConstraintNode;
+}
+interface PrimaryKeyConstraintBuilder {
+    deferrable(): PrimaryKeyConstraintBuilder;
+    notDeferrable(): PrimaryKeyConstraintBuilder;
+    initiallyDeferred(): PrimaryKeyConstraintBuilder;
+    initiallyImmediate(): PrimaryKeyConstraintBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): PrimaryKeyConstraintNode;
+}
+export interface AlterTableBuilder<TName extends string, TOps extends AlterOperation[] = []> {
     readonly __tableName: TName;
-    readonly __addedColumns: TSchema;
-    renameTo<TNewName extends string>(newTableName: TNewName): AlterTableBuilder<TNewName, TSchema>;
-    setSchema(newSchema: string): AlterTableBuilder<TName, TSchema>;
-    addColumn<K extends string, T extends string>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, Prettify<TSchema & Record<K, SqlToTsType<T>>>>;
-    dropColumn<K extends string>(name: K): AlterTableBuilder<TName, Prettify<TSchema & {
-        [P in K]: never;
-    }>>;
-    renameColumn<KFrom extends string, KTo extends string>(from: KFrom, to: KTo): AlterTableBuilder<TName, Prettify<TSchema & {
-        [P in KFrom]: never;
-    } & {
-        [P in KTo]: any;
-    }>>;
-    alterColumn<K extends string>(column: K, alteration: AlterColumnBuilderCallback): AlterTableBuilder<TName, TSchema>;
-    modifyColumn<K extends string, T extends string>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, Prettify<TSchema & Record<K, SqlToTsType<T>>>>;
+    readonly __operations: TOps;
+    renameTo<TNewName extends string>(newTableName: TNewName): AlterTableBuilder<TNewName, TOps> & {
+        readonly __renamedFrom: TName;
+    };
+    setSchema(newSchema: string): AlterTableBuilder<TName, TOps>;
+    addColumn<K extends string, T extends DataTypeExpression>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, [...TOps, AddColumnOp<K, T>]>;
+    dropColumn<K extends string>(name: K): AlterTableBuilder<TName, [...TOps, DropColumnOp<K>]>;
+    renameColumn<KFrom extends string, KTo extends string>(from: KFrom, to: KTo): AlterTableBuilder<TName, [...TOps, RenameColumnOp<KFrom, KTo>]>;
+    alterColumn<K extends string, const TCallback extends AlterColumnBuilderCallback>(column: K, alteration: TCallback): AlterTableBuilder<TName, [
+        ...TOps,
+        AlterColumnOp<K, ReturnType<TCallback>["__alteration"]>
+    ]>;
+    modifyColumn<K extends string, T extends DataTypeExpression>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, [...TOps, ModifyColumnOp<K, T>]>;
+    addUniqueConstraint(constraintName: string, columns: string[], build?: (builder: UniqueConstraintBuilder) => UniqueConstraintBuilder): AlterTableBuilder<TName, TOps>;
+    addPrimaryKeyConstraint(constraintName: string, columns: string[], build?: (builder: PrimaryKeyConstraintBuilder) => PrimaryKeyConstraintBuilder): AlterTableBuilder<TName, TOps>;
+    addCheckConstraint(constraintName: string, checkExpression: Expression<any>, build?: (builder: CheckConstraintBuilder) => CheckConstraintBuilder): AlterTableBuilder<TName, TOps>;
+    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[], build?: (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder): AlterTableBuilder<TName, TOps>;
+    dropConstraint(constraintName: string): AlterTableBuilder<TName, TOps>;
+    renameConstraint(oldName: string, newName: string): AlterTableBuilder<TName, TOps>;
+    addIndex(indexName: string): AlterTableBuilder<TName, TOps>;
+    dropIndex(indexName: string): AlterTableBuilder<TName, TOps>;
     execute(): Promise<ExecutedBuilder<this>>;
+    $call<T>(func: (qb: this) => T): T;
 }
+export {};

package/dist/runtime/lib/db/typeInference/builders/columnDefinition.d.ts

@@ -1,9 +1,26 @@
-export interface ColumnDefinitionBuilder<T = any> {
-    primaryKey(): ColumnDefinitionBuilder<T>;
-    notNull(): ColumnDefinitionBuilder<T>;
-    unique(): ColumnDefinitionBuilder<T>;
-    defaultTo<V extends T>(value: V): ColumnDefinitionBuilder<T>;
-    references(ref: string): ColumnDefinitionBuilder<T>;
-    onDelete(action: "cascade" | "restrict" | "set null"): ColumnDefinitionBuilder<T>;
-    unsigned(): ColumnDefinitionBuilder<T>;
+import { Expression, sql, ColumnDefinitionNode } from "kysely";
+type DefaultValueExpression = string | number | boolean | null | typeof sql;
+export interface ColumnDefinitionBuilder<TType> {
+    autoIncrement(): ColumnDefinitionBuilder<TType>;
+    identity(): ColumnDefinitionBuilder<TType>;
+    primaryKey(): ColumnDefinitionBuilder<TType>;
+    references(ref: string): ColumnDefinitionBuilder<TType>;
+    onDelete(onDelete: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType>;
+    onUpdate(onUpdate: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType>;
+    unique(): ColumnDefinitionBuilder<TType>;
+    notNull(): ColumnDefinitionBuilder<TType>;
+    unsigned(): ColumnDefinitionBuilder<TType>;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder<TType>;
+    check(expression: Expression<any>): ColumnDefinitionBuilder<TType>;
+    generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder<TType>;
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder<TType>;
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder<TType>;
+    stored(): ColumnDefinitionBuilder<TType>;
+    modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder<TType>;
+    nullsNotDistinct(): ColumnDefinitionBuilder<TType>;
+    ifNotExists(): ColumnDefinitionBuilder<TType>;
+    modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder<TType>;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): ColumnDefinitionNode;
 }
+export {};

package/dist/runtime/lib/db/typeInference/builders/createTable.d.ts

@@ -1,14 +1,49 @@
 import { SqlToTsType, ExecutedBuilder, Prettify } from "../utils";
 import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { CompiledQuery, CreateTableNode, Expression, ForeignKeyConstraintBuilder, CheckConstraintNode, UniqueConstraintNode, PrimaryKeyConstraintNode } from "kysely";
+interface CheckConstraintBuilder {
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): CheckConstraintNode;
+}
+interface UniqueConstraintBuilder {
+    nullsNotDistinct(): UniqueConstraintBuilder;
+    deferrable(): UniqueConstraintBuilder;
+    notDeferrable(): UniqueConstraintBuilder;
+    initiallyDeferred(): UniqueConstraintBuilder;
+    initiallyImmediate(): UniqueConstraintBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): UniqueConstraintNode;
+}
+interface PrimaryKeyConstraintBuilder {
+    deferrable(): PrimaryKeyConstraintBuilder;
+    notDeferrable(): PrimaryKeyConstraintBuilder;
+    initiallyDeferred(): PrimaryKeyConstraintBuilder;
+    initiallyImmediate(): PrimaryKeyConstraintBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): PrimaryKeyConstraintNode;
+}
 export interface CreateTableBuilder<TName extends string, TSchema extends Record<string, any> = {}> {
     readonly __tableName: TName;
     readonly __addedColumns: TSchema;
     temporary(): CreateTableBuilder<TName, TSchema>;
     onCommit(onCommit: "preserve rows" | "delete rows" | "drop"): CreateTableBuilder<TName, TSchema>;
     ifNotExists(): CreateTableBuilder<TName, TSchema>;
-    addColumn<K extends string, T extends string>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): CreateTableBuilder<TName, Prettify<TSchema & Record<K, SqlToTsType<T>>>>;
-    modifyFront(modifier: string): CreateTableBuilder<TName, TSchema>;
-    modifyEnd(modifier: string): CreateTableBuilder<TName, TSchema>;
-    as(expression: string): CreateTableBuilder<TName, TSchema>;
+    addColumn<K extends string, T extends string>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, SqlToTsType<T>>>>;
+    addUniqueConstraint(constraintName: string, columns: (keyof TSchema)[], build?: (builder: UniqueConstraintBuilder) => UniqueConstraintBuilder): CreateTableBuilder<TName, TSchema>;
+    addPrimaryKeyConstraint(constraintName: string, columns: (keyof TSchema)[], build?: (builder: PrimaryKeyConstraintBuilder) => PrimaryKeyConstraintBuilder): CreateTableBuilder<TName, TSchema>;
+    addCheckConstraint(constraintName: string, checkExpression: Expression<any>, build?: (builder: CheckConstraintBuilder) => CheckConstraintBuilder): CreateTableBuilder<TName, TSchema>;
+    addForeignKeyConstraint(constraintName: string, columns: (keyof TSchema)[], targetTable: string, targetColumns: string[], build?: (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder): CreateTableBuilder<TName, TSchema>;
+    modifyFront(modifier: Expression<any>): CreateTableBuilder<TName, TSchema>;
+    modifyEnd(modifier: Expression<any>): CreateTableBuilder<TName, TSchema>;
+    as(expression: Expression<any>): CreateTableBuilder<TName, TSchema>;
     execute(): Promise<ExecutedBuilder<this>>;
+    $call<T>(func: (qb: this) => T): T;
+    compile(): CompiledQuery;
+    toOperationNode(): CreateTableNode;
+    withSchema(schema: string): CreateTableBuilder<TName, TSchema>;
+    ownerTo(owner: string): CreateTableBuilder<TName, TSchema>;
+    replace(): CreateTableBuilder<TName, TSchema>;
+    ignore(): CreateTableBuilder<TName, TSchema>;
+    withoutTableConstraintValidation(): CreateTableBuilder<TName, TSchema>;
 }
+export {};

package/dist/runtime/lib/db/typeInference/builders/createView.d.ts

@@ -1,13 +1,17 @@
 import { ExecutedBuilder } from "../utils";
+import { CreateViewNode, CompiledQuery, SelectQueryBuilder, RawBuilder } from "kysely";
 export interface CreateViewBuilder<TName extends string, TSchema extends Record<string, any> = {}, TColumns extends string[] = []> {
     readonly __viewName: TName;
     readonly __schema: TSchema;
     readonly __columns: TColumns;
-    withSchema<S extends Record<string, any>>(): CreateViewBuilder<TName, S, TColumns>;
     temporary(): CreateViewBuilder<TName, TSchema, TColumns>;
     orReplace(): CreateViewBuilder<TName, TSchema, TColumns>;
     ifNotExists(): CreateViewBuilder<TName, TSchema, TColumns>;
     columns<C extends string[]>(columns: C): CreateViewBuilder<TName, TSchema, C>;
-    as<E extends string>(expression: E): CreateViewBuilder<TName, TSchema, TColumns>;
+    as(query: SelectQueryBuilder<any, any, any> | RawBuilder<any>): CreateViewBuilder<TName, TSchema, TColumns>;
     execute(): Promise<ExecutedBuilder<this>>;
+    toOperationNode(): CreateViewNode;
+    compile(): CompiledQuery;
+    $call<T>(func: (qb: this) => T): T;
+    materialized(): CreateViewBuilder<TName, TSchema, TColumns>;
 }

package/dist/runtime/lib/db/typeInference/builders/dropTable.d.ts

@@ -1,7 +1,11 @@
 import { ExecutedBuilder } from "../utils";
+import { DropTableNode, CompiledQuery } from "kysely";
 export interface DropTableBuilder<TName extends string> {
     readonly __tableName: TName;
     ifExists(): DropTableBuilder<TName>;
     cascade(): DropTableBuilder<TName>;
     execute(): Promise<ExecutedBuilder<this>>;
+    toOperationNode(): DropTableNode;
+    compile(): CompiledQuery;
+    $call<T>(func: (qb: this) => T): T;
 }

package/dist/runtime/lib/db/typeInference/builders/dropView.d.ts

@@ -1,7 +1,12 @@
 import { ExecutedBuilder } from "../utils";
+import { DropViewNode, CompiledQuery } from "kysely";
 export interface DropViewBuilder<TName extends string> {
     readonly __viewName: TName;
     ifExists(): DropViewBuilder<TName>;
     cascade(): DropViewBuilder<TName>;
     execute(): Promise<ExecutedBuilder<this>>;
+    toOperationNode(): DropViewNode;
+    compile(): CompiledQuery;
+    $call<T>(func: (qb: this) => T): T;
+    materialized(): DropViewBuilder<TName>;
 }

package/dist/runtime/lib/db/typeInference/builders/schema.d.ts

@@ -1,12 +1,24 @@
-import { TableBuilder } from "./table";
+import { CreateTableBuilder } from "./createTable";
 import { AlterTableBuilder } from "./alterTable";
 import { DropTableBuilder } from "./dropTable";
 import { CreateViewBuilder } from "./createView";
 import { DropViewBuilder } from "./dropView";
+import { CreateIndexBuilder, DropIndexBuilder, CreateSchemaBuilder, DropSchemaBuilder, CreateTypeBuilder, DropTypeBuilder, KyselyPlugin, RefreshMaterializedViewBuilder } from "kysely";
 export interface SchemaBuilder {
-    createTable<TName extends string>(name: TName): TableBuilder<TName, {}>;
-    alterTable<TName extends string>(name: TName): AlterTableBuilder<TName, {}>;
+    createTable<TName extends string>(name: TName): CreateTableBuilder<TName, {}>;
+    alterTable<TName extends string>(name: TName): AlterTableBuilder<TName, []>;
     dropTable<TName extends string>(name: TName): DropTableBuilder<TName>;
-    createView<TName extends string>(name: TName): CreateViewBuilder<TName, {}>;
+    createView<TName extends string>(name: TName): CreateViewBuilder<TName, never>;
     dropView<TName extends string>(name: TName): DropViewBuilder<TName>;
+    withSchema(schema: string): this;
+    createIndex(name: string): CreateIndexBuilder;
+    dropIndex(name: string): DropIndexBuilder;
+    createSchema(name: string): CreateSchemaBuilder;
+    dropSchema(name: string): DropSchemaBuilder;
+    createType(name: string): CreateTypeBuilder;
+    dropType(name: string): DropTypeBuilder;
+    refreshMaterializedView(viewName: string): RefreshMaterializedViewBuilder;
+    $call<T>(func: (qb: this) => T): T;
+    withPlugin(plugin: KyselyPlugin): this;
+    withoutPlugins(): this;
 }

package/dist/runtime/lib/db/typeInference/database.d.ts

@@ -1,10 +1,8 @@
 import { Kysely } from "kysely";
-import { ExecutedBuilder, Prettify, MergeSchemas, OmitNever, UnionToIntersection } from "./utils";
-import { TableBuilder } from "./builders/table";
-import { CreateViewBuilder } from "./builders/createView.js";
-import { AlterTableBuilder } from "./builders/alterTable.js";
-import { DropTableBuilder } from "./builders/dropTable.js";
-import { DropViewBuilder } from "./builders/dropView.js";
+import { ExecutedBuilder, Prettify, ProcessAlteredTable, UnionToTuple } from "./utils";
+import { CreateTableBuilder } from "./builders/createTable";
+import { AlterTableBuilder } from "./builders/alterTable";
+import { DropTableBuilder } from "./builders/dropTable";
 import { SchemaBuilder } from "./builders/schema";
 export interface InferenceBuilder {
     schema: SchemaBuilder;
@@ -17,22 +15,13 @@ export interface Migration<TUpReturn = unknown> {
 export type Migrations = Record<string, Migration>;
 type GetBuilder<T> = T extends ExecutedBuilder<infer B> ? B : never;
 type BuildersFromMigration<TMigration extends Migration> = TMigration extends Migration<infer TUpReturn> ? Awaited<TUpReturn> extends Array<infer Item> ? GetBuilder<Item> : GetBuilder<Awaited<TUpReturn>> : never;
-type AllBuilders<TMigrations extends Migrations> = BuildersFromMigration<TMigrations[keyof TMigrations]>;
-type CreatedTables<TMigrations extends Migrations> = UnionToIntersection<ExtractTableSchema<Extract<AllBuilders<TMigrations>, TableBuilder<any, any>>>>;
-type CreatedViews<TMigrations extends Migrations> = UnionToIntersection<ExtractViewSchema<Extract<AllBuilders<TMigrations>, CreateViewBuilder<any, any>>>>;
-type AlteredTables<TMigrations extends Migrations> = UnionToIntersection<ExtractAlterSchema<Extract<AllBuilders<TMigrations>, AlterTableBuilder<any, any>>>>;
-type DroppedTableNames<TMigrations extends Migrations> = ExtractDroppedTableName<Extract<AllBuilders<TMigrations>, DropTableBuilder<any>>>;
-type DroppedViewNames<TMigrations extends Migrations> = ExtractDroppedViewName<Extract<AllBuilders<TMigrations>, DropViewBuilder<any>>>;
-type AllCreated<TMigrations extends Migrations> = MergeSchemas<CreatedTables<TMigrations>, CreatedViews<TMigrations>>;
-type MergedSchemaBeforeDrop<TMigrations extends Migrations> = MergeSchemas<AllCreated<TMigrations>, AlteredTables<TMigrations>>;
-type CleanedSchema<T> = {
-    [K in keyof T]: OmitNever<T[K]>;
-};
-type InferredDatabase<TMigrations extends Migrations> = Omit<Omit<CleanedSchema<MergedSchemaBeforeDrop<TMigrations>>, DroppedTableNames<TMigrations>>, DroppedViewNames<TMigrations>>;
-export type Database<TMigrations extends Migrations = Migrations> = Prettify<InferredDatabase<TMigrations>>;
-export type ExtractTableSchema<T> = T extends TableBuilder<infer TName, infer TSchema> ? Record<TName, TSchema> : never;
-export type ExtractViewSchema<T> = T extends CreateViewBuilder<infer TName, infer TSchema> ? Record<TName, TSchema> : never;
-export type ExtractAlterSchema<T> = T extends AlterTableBuilder<infer TName, infer TSchema> ? Record<TName, TSchema> : never;
-export type ExtractDroppedTableName<T> = T extends DropTableBuilder<infer TName> ? TName : never;
-export type ExtractDroppedViewName<T> = T extends DropViewBuilder<infer TName> ? TName : never;
+type ApplyBuilder<TSchema, TBuilder> = TBuilder extends CreateTableBuilder<infer TName, infer TSch> ? Prettify<TSchema & Record<TName, TSch>> : TBuilder extends DropTableBuilder<infer TName> ? Omit<TSchema, TName> : TBuilder extends AlterTableBuilder<infer TName, infer TOps> ? TBuilder extends {
+    __renamedFrom: infer From extends string;
+} ? From extends keyof TSchema ? Prettify<Omit<TSchema, From> & Record<TName, ProcessAlteredTable<TSchema[From], TOps>>> : TSchema : TName extends keyof TSchema ? Prettify<Omit<TSchema, TName> & Record<TName, ProcessAlteredTable<TSchema[TName], TOps>>> : TSchema : TSchema;
+type ApplyBuilders<TSchema, TBuildersTuple> = TBuildersTuple extends [
+    infer THead,
+    ...infer TRest
+] ? ApplyBuilders<ApplyBuilder<TSchema, THead>, TRest> : TSchema;
+type ProcessMigrations<TMigrations extends Migrations, TKeys, TSchema = {}> = TKeys extends [infer THeadKey, ...infer TRestKeys] ? THeadKey extends keyof TMigrations ? ProcessMigrations<TMigrations, TRestKeys, ApplyBuilders<TSchema, UnionToTuple<BuildersFromMigration<TMigrations[THeadKey]>>>> : TSchema : TSchema;
+export type Database<TMigrations extends Migrations = Migrations> = ProcessMigrations<TMigrations, UnionToTuple<keyof TMigrations>>;
 export {};

package/dist/runtime/lib/db/typeInference/typetests/alterTable.typetest.js

@@ -23,15 +23,37 @@
     };
     (_test) => { };
 };
-(_it = "alterTable renameColumn and dropColumn") => {
+(_it = "alterTable renameColumn") => {
+    const migrations = {
+        "0001_initial": {
+            up: async (db) => [
+                await db.schema
+                    .createTable("users")
+                    .addColumn("id", "integer", (c) => c.primaryKey().autoIncrement())
+                    .addColumn("username", "text")
+                    .addColumn("displayName", "text")
+                    .execute(),
+            ],
+        },
+        "0002_rename_column": {
+            up: async (db) => [
+                await db.schema
+                    .alterTable("users")
+                    .renameColumn("displayName", "nickname")
+                    .execute(),
+            ],
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable alterColumn setDataType and setDefault") => {
     const migrations = {
         "0": {
             async up(db) {
                 return [
                     await db.schema
                         .createTable("users")
-                        .addColumn("username", "text")
-                        .addColumn("displayName", "text")
+                        .addColumn("age", "integer")
                         .execute(),
                 ];
             },
@@ -41,8 +63,8 @@
                 return [
                     await db.schema
                         .alterTable("users")
-                        .renameColumn("displayName", "nickname")
-                        .dropColumn("username")
+                        .alterColumn("age", (col) => col.setDataType("text"))
+                        .alterColumn("age", (col) => col.setDefault("unknown"))
                         .execute(),
                 ];
             },
@@ -50,32 +72,60 @@
     };
     (_test) => { };
 };
-(_it = "alterTable alterColumn setDataType and setDefault") => {
+(_it = "alterTable alterColumn dropDefault, setNotNull, dropNotNull") => {
     const migrations = {
         "0": {
             async up(db) {
                 return [
-                    db.schema.createTable("users").addColumn("age", "integer").execute(),
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("age", "integer")
+                        .execute(),
                 ];
             },
         },
         "1": {
             async up(db) {
                 return [
-                    db.schema
+                    await db.schema
                         .alterTable("users")
-                        .alterColumn("age", (col) => col.setDataType("text"))
-                        .alterColumn("age", (col) => col.setDefault("unknown"))
+                        .alterColumn("age", (col) => col.dropDefault())
+                        .alterColumn("age", (col) => col.setNotNull())
+                        .alterColumn("age", (col) => col.dropNotNull())
                         .execute(),
                 ];
             },
         },
     };
-    // todo(justinvdm, 2024-01-08): Support setDataType()
-    // @ts-ignore
-    (_test) => { };
+    //(_test: Expect<Equal<Actual, Expected>>) => {};
 };
-(_it = "alterTable alterColumn dropDefault, setNotNull, dropNotNull") => {
+(_it = "alterTable addUniqueConstraint") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("firstName", "text")
+                        .addColumn("lastName", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .addUniqueConstraint("unique_name", ["firstName", "lastName"])
+                        .execute(),
+                ];
+            },
+        },
+    };
+    //(_test: Expect<Equal<Actual, Expected>>) => {};
+};
+(_it = "alterTable drop column") => {
     const migrations = {
         "0": {
             async up(db) {
@@ -87,14 +137,219 @@
                 ];
             },
         },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").dropColumn("age").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameTable") => {
+    const migrations = {
+        "0001_initial": {
+            up: async (db) => [
+                await db.schema
+                    .createTable("users")
+                    .addColumn("id", "integer")
+                    .execute(),
+            ],
+        },
+        "0002_rename_table": {
+            up: async (db) => [
+                await db.schema.alterTable("users").renameTo("customers").execute(),
+            ],
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameColumn then rename again") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
         "1": {
             async up(db) {
                 return [
                     await db.schema
                         .alterTable("users")
-                        .alterColumn("age", (col) => col.dropDefault())
-                        .alterColumn("age", (col) => col.setNotNull())
-                        .alterColumn("age", (col) => col.dropNotNull())
+                        .renameColumn("name", "firstName")
+                        .execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("firstName", "givenName")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameColumn then rename back") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("name", "firstName")
+                        .execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("firstName", "name")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameTable then rename again") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").renameTo("customers").execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("customers").renameTo("clients").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameTable then rename back") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").renameTo("customers").execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("customers").renameTo("users").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameColumn then drop") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("name", "firstName")
+                        .execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").dropColumn("firstName").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable dropColumn then add back") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").dropColumn("name").execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .addColumn("name", "text")
                         .execute(),
                 ];
             },

package/dist/runtime/lib/db/typeInference/typetests/dropTable.typetest.js

@@ -83,4 +83,61 @@
     };
     (_test) => { };
 };
+(_it = "drop table then add it back") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [await db.schema.dropTable("users").execute()];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "rename table then drop it") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").renameTo("customers").execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [await db.schema.dropTable("customers").execute()];
+            },
+        },
+    };
+    (_test) => { };
+};
 export {};

package/dist/runtime/lib/db/typeInference/typetests/print.d.ts

@@ -0,0 +1,3 @@
+export type PrintType<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;

package/dist/runtime/lib/db/typeInference/typetests/print.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/utils.d.ts

@@ -1,14 +1,82 @@
-export type SqlToTsType<T extends string> = T extends "text" ? string : T extends "integer" ? number : T extends "blob" ? Uint8Array : T extends "real" ? number : T extends "boolean" ? boolean : never;
+import { sql } from "kysely";
+type DataTypeExpression = string | typeof sql;
+export type AddColumnOp<K extends string, T extends DataTypeExpression> = {
+    op: "addColumn";
+    name: K;
+    type: T;
+};
+export type DropColumnOp<K extends string> = {
+    op: "dropColumn";
+    name: K;
+};
+export type RenameColumnOp<KFrom extends string, KTo extends string> = {
+    op: "renameColumn";
+    from: KFrom;
+    to: KTo;
+};
+export type ModifyColumnOp<K extends string, T extends DataTypeExpression> = {
+    op: "modifyColumn";
+    name: K;
+    type: T;
+};
+export type Alteration = {
+    kind: "setDataType";
+    dataType: string;
+} | {
+    kind: "setDefault";
+    value: any;
+} | {
+    kind: "dropDefault";
+} | {
+    kind: "setNotNull";
+} | {
+    kind: "dropNotNull";
+};
+export type AlterColumnOp<K extends string, TAlteration extends Alteration> = {
+    op: "alterColumn";
+    name: K;
+    alteration: TAlteration;
+};
+export type AlterOperation = AddColumnOp<any, any> | DropColumnOp<any> | RenameColumnOp<any, any> | AlterColumnOp<any, any> | ModifyColumnOp<any, any>;
+export type SqlToTsType<T extends string | typeof sql> = T extends "text" ? string : T extends "integer" ? number : T extends "blob" ? Uint8Array : T extends "real" ? number : T extends "boolean" ? boolean : T extends typeof sql ? any : never;
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
 export type ExecutedBuilder<T> = {
     __builder_type: T;
 };
-export type MergeSchemas<A, B> = {
-    [K in keyof A | keyof B]: K extends keyof A ? K extends keyof B ? Prettify<A[K] & B[K]> : A[K] : K extends keyof B ? B[K] : never;
-};
+export type MergeSchemas<A, B> = Prettify<Omit<A, keyof B> & B>;
 export type OmitNever<T> = {
     [K in keyof T as T[K] extends never ? never : K]: T[K];
 };
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type DeepClean<T> = T extends Uint8Array ? T : T extends Record<string, any> ? {
+    [K in keyof T as T[K] extends never ? never : K]: DeepClean<T[K]>;
+} & {} : T;
+export type Cast<A, B> = A extends B ? A : B;
+/**
+ * Applies a single alteration operation to a schema.
+ */
+type ApplyOp<TSchema, THeadOp> = THeadOp extends AddColumnOp<infer K, infer T> ? Prettify<TSchema & {
+    [P in K]: SqlToTsType<T>;
+}> : THeadOp extends DropColumnOp<infer K> ? Omit<TSchema, K> : THeadOp extends RenameColumnOp<infer KFrom, infer KTo> ? KFrom extends keyof TSchema ? Prettify<Omit<TSchema, KFrom> & {
+    [P in KTo]: TSchema[KFrom];
+}> : TSchema : THeadOp extends AlterColumnOp<infer K, infer TAlt> ? TAlt extends {
+    kind: "setDataType";
+    dataType: infer DT extends string;
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: SqlToTsType<DT>;
+}> : TSchema : THeadOp extends ModifyColumnOp<infer K, infer T> ? Prettify<Omit<TSchema, K> & {
+    [P in K]: SqlToTsType<T>;
+}> : TSchema;
+/**
+ * Recursively processes a list of alteration operations (AST)
+ * to transform an initial schema into the final schema.
+ */
+export type ProcessAlteredTable<TInitialSchema, TOps> = TOps extends [
+    infer THeadOp,
+    ...infer TRestOps
+] ? ProcessAlteredTable<ApplyOp<TInitialSchema, THeadOp>, TRestOps> : TInitialSchema;
+type LastOf<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? R : never;
+export type UnionToTuple<U, Last = LastOf<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
+export {};

package/dist/runtime/lib/db/typeInference/utils.js

@@ -1 +1,2 @@
 export {};
+// --- End Union to Tuple Helpers ---

package/dist/runtime/lib/realtime/client.js

@@ -1,6 +1,5 @@
 import { initClient } from "../../client";
 import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
-import { IS_DEV } from "../../constants";
 import { MESSAGE_TYPE } from "./shared";
 const DEFAULT_KEY = "default";
 export const initRealtimeClient = ({ key = DEFAULT_KEY, } = {}) => {
@@ -12,12 +11,13 @@ export const realtimeTransport = ({ key = DEFAULT_KEY }) => (transportContext) =
     let isConnected = false;
     const clientId = crypto.randomUUID();
     const clientUrl = new URL(window.location.href);
+    const isHttps = clientUrl.protocol === "https:";
     clientUrl.protocol = "";
     clientUrl.host = "";
     const setupWebSocket = () => {
         if (ws)
             return;
-        const protocol = IS_DEV ? "ws" : "wss";
+        const protocol = isHttps ? "wss" : "ws";
         ws = new WebSocket(`${protocol}://${window.location.host}/__realtime?` +
             `key=${encodeURIComponent(key)}&` +
             `url=${encodeURIComponent(clientUrl.toString())}&` +

package/dist/scripts/debug-sync.d.mts

@@ -1,8 +1,6 @@
 export interface DebugSyncOptions {
     targetDir: string;
     sdkDir?: string;
-    dev?: boolean;
-    watch?: boolean;
-    build?: boolean;
+    watch?: string | boolean;
 }
 export declare const debugSync: (opts: DebugSyncOptions) => Promise<void>;

package/dist/scripts/debug-sync.mjs

@@ -1,26 +1,38 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { $ } from "../lib/$.mjs";
+import { $ } from "execa";
 import fs from "node:fs/promises";
 import { existsSync } from "node:fs";
+import chokidar from "chokidar";
+import { lock } from "proper-lockfile";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageManagerInfo = (targetDir) => {
+    const pnpmResult = {
+        name: "pnpm",
+        lockFile: "pnpm-lock.yaml",
+        command: "add",
+    };
     if (existsSync(path.join(targetDir, "yarn.lock"))) {
         return { name: "yarn", lockFile: "yarn.lock", command: "add" };
     }
     if (existsSync(path.join(targetDir, "pnpm-lock.yaml"))) {
-        return { name: "pnpm", lockFile: "pnpm-lock.yaml", command: "add" };
+        return pnpmResult;
     }
-    return { name: "npm", lockFile: "package-lock.json", command: "install" };
+    if (existsSync(path.join(targetDir, "package-lock.json"))) {
+        return { name: "npm", lockFile: "package-lock.json", command: "install" };
+    }
+    return pnpmResult;
 };
-const performSync = async (sdkDir, targetDir) => {
-    console.log("🏗️  rebuilding sdk...");
-    await $({ cwd: sdkDir, stdio: "inherit", shell: true }) `pnpm build`;
-    console.log("📦 packing sdk...");
-    const packResult = await $({ cwd: sdkDir, shell: true }) `npm pack`;
+const performFullSync = async (sdkDir, targetDir) => {
+    console.log("📦 Packing SDK...");
+    const packResult = await $ `npm pack`;
     const tarballName = packResult.stdout?.trim() ?? "";
+    if (!tarballName) {
+        console.error("❌ Failed to get tarball name from npm pack.");
+        return;
+    }
     const tarballPath = path.resolve(sdkDir, tarballName);
-    console.log(` installing ${tarballName} in ${targetDir}...`);
+    console.log(`💿 Installing ${tarballName} in ${targetDir}...`);
     const pm = getPackageManagerInfo(targetDir);
     const packageJsonPath = path.join(targetDir, "package.json");
     const lockfilePath = path.join(targetDir, pm.lockFile);
@@ -31,15 +43,18 @@ const performSync = async (sdkDir, targetDir) => {
         .readFile(lockfilePath, "utf-8")
         .catch(() => null);
     try {
-        let installCommand = `${pm.name} ${pm.command} ${tarballPath}`;
+        const cmd = pm.name;
+        const args = [pm.command];
         if (pm.name === "yarn") {
-            installCommand = `yarn add file:${tarballPath}`;
+            args.push(`file:${tarballPath}`);
         }
-        await $({
+        else {
+            args.push(tarballPath);
+        }
+        await $(cmd, args, {
             cwd: targetDir,
             stdio: "inherit",
-            shell: true,
-        }) `${installCommand}`;
+        });
     }
     finally {
         if (originalPackageJson) {
@@ -54,67 +69,140 @@ const performSync = async (sdkDir, targetDir) => {
             // ignore if deletion fails
         });
     }
-    console.log("✅ done syncing");
+};
+const performFastSync = async (sdkDir, targetDir) => {
+    console.log("⚡️ No dependency changes, performing fast sync...");
+    const sdkPackageJson = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"));
+    const filesToSync = sdkPackageJson.files || [];
+    for (const file of filesToSync) {
+        const source = path.join(sdkDir, file);
+        const destination = path.join(targetDir, "node_modules/rwsdk", file);
+        if (existsSync(source)) {
+            await fs.cp(source, destination, { recursive: true, force: true });
+        }
+    }
+    // Always copy package.json
+    await fs.copyFile(path.join(sdkDir, "package.json"), path.join(targetDir, "node_modules/rwsdk/package.json"));
+};
+const performSync = async (sdkDir, targetDir) => {
+    console.log("🏗️  Rebuilding SDK...");
+    await $ `pnpm build`;
+    const sdkPackageJsonPath = path.join(sdkDir, "package.json");
+    const installedSdkPackageJsonPath = path.join(targetDir, "node_modules/rwsdk/package.json");
+    let packageJsonChanged = true;
+    if (existsSync(installedSdkPackageJsonPath)) {
+        const sdkPackageJsonContent = await fs.readFile(sdkPackageJsonPath, "utf-8");
+        const installedSdkPackageJsonContent = await fs.readFile(installedSdkPackageJsonPath, "utf-8");
+        if (sdkPackageJsonContent === installedSdkPackageJsonContent) {
+            packageJsonChanged = false;
+        }
+    }
+    if (packageJsonChanged) {
+        console.log("📦 package.json changed, performing full sync...");
+        await performFullSync(sdkDir, targetDir);
+    }
+    else {
+        await performFastSync(sdkDir, targetDir);
+    }
+    console.log("✅ Done syncing");
 };
 export const debugSync = async (opts) => {
-    const { targetDir, sdkDir = process.cwd(), dev, watch, build } = opts;
+    const { targetDir, sdkDir = process.cwd(), watch } = opts;
     if (!targetDir) {
         console.error("❌ Please provide a target directory as an argument.");
         process.exit(1);
     }
-    const thisScriptPath = fileURLToPath(import.meta.url);
-    const syncCommand = `tsx ${thisScriptPath} --_sync ${sdkDir} ${targetDir}`;
-    // Run initial sync
-    await performSync(sdkDir, targetDir);
-    if (!process.env.NO_CLEAN_VITE) {
-        console.log("🧹 Cleaning Vite cache...");
-        await $({
-            stdio: "inherit",
-            shell: true,
-            cwd: targetDir,
-        }) `rm -rf ${targetDir}/node_modules/.vite*`;
-    }
-    // If dev flag is present, clean vite cache and start dev server
-    if (dev) {
-        console.log("🚀 Starting dev server...");
-        await $({ stdio: "inherit", shell: true, cwd: targetDir }) `npm run dev`;
+    // If not in watch mode, just do a one-time sync and exit.
+    if (!watch) {
+        await performSync(sdkDir, targetDir);
+        return;
     }
-    // Start watching if watch flag is present
-    else if (watch) {
-        console.log("👀 Watching for changes...");
-        $({
-            stdio: "inherit",
-            shell: true,
-            cwd: sdkDir,
-        }) `npx chokidar-cli './src/**' './package.json' -c "${syncCommand}"`;
+    // --- Watch Mode Logic ---
+    const lockfilePath = path.join(targetDir, "node_modules", ".rwsync.lock");
+    let release;
+    // Ensure the directory for the lockfile exists
+    await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
+    // "Touch" the file to ensure it exists before locking
+    await fs.appendFile(lockfilePath, "").catch(() => { });
+    try {
+        release = await lock(lockfilePath, { retries: 0 });
     }
-    else if (build) {
-        console.log("🏗️ Running build in target directory...");
-        await $({
-            stdio: "inherit",
-            shell: true,
-            cwd: targetDir,
-        }) `npm run build`;
+    catch (e) {
+        if (e.code === "ELOCKED") {
+            console.error(`❌ Another rwsync process is already watching ${targetDir}.`);
+            console.error(`   If this is not correct, please remove the lockfile at ${lockfilePath}`);
+            process.exit(1);
+        }
+        throw e;
     }
+    // Initial sync for watch mode. We do it *after* acquiring the lock.
+    await performSync(sdkDir, targetDir);
+    const filesToWatch = [
+        path.join(sdkDir, "src"),
+        path.join(sdkDir, "types"),
+        path.join(sdkDir, "bin"),
+        path.join(sdkDir, "package.json"),
+    ];
+    console.log("👀 Watching for changes...");
+    let childProc = null;
+    const runWatchedCommand = () => {
+        if (typeof watch === "string") {
+            console.log(`\n> ${watch}\n`);
+            childProc = $({
+                stdio: "inherit",
+                shell: true,
+                cwd: targetDir,
+                reject: false,
+            }) `${watch}`;
+        }
+    };
+    const watcher = chokidar.watch(filesToWatch, {
+        ignoreInitial: true,
+        cwd: sdkDir,
+    });
+    watcher.on("all", async () => {
+        console.log("\nDetected change, re-syncing...");
+        if (childProc && !childProc.killed) {
+            console.log("Stopping running process...");
+            childProc.kill();
+            await childProc.catch(() => {
+                /* ignore kill errors */
+            });
+        }
+        await performSync(sdkDir, targetDir);
+        runWatchedCommand();
+    });
+    const cleanup = async () => {
+        console.log("\nCleaning up...");
+        if (childProc && !childProc.killed) {
+            childProc.kill();
+        }
+        await release();
+        process.exit();
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    runWatchedCommand();
 };
 if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
     const args = process.argv.slice(2);
-    const flags = new Set(args.filter((arg) => arg.startsWith("--")));
-    const positionalArgs = args.filter((arg) => !arg.startsWith("--"));
-    if (flags.has("--_sync")) {
-        const [sdkDir, targetDir] = positionalArgs;
-        await performSync(sdkDir, targetDir);
-    }
-    else {
-        const targetDir = positionalArgs[0] ?? process.cwd();
-        debugSync({
-            targetDir,
-            sdkDir: process.env.RWSDK_REPO
-                ? path.resolve(__dirname, process.env.RWSDK_REPO, "sdk")
-                : path.resolve(__dirname, "..", ".."),
-            dev: flags.has("--dev"),
-            watch: flags.has("--watch"),
-            build: flags.has("--build"),
-        });
+    const watchFlagIndex = args.indexOf("--watch");
+    let watchCmd = watchFlagIndex !== -1;
+    let cmdArgs = args;
+    if (watchFlagIndex !== -1) {
+        if (watchFlagIndex + 1 < args.length &&
+            !args[watchFlagIndex + 1].startsWith("--")) {
+            watchCmd = args[watchFlagIndex + 1];
+        }
+        // remove --watch and its potential command from args
+        const watchArgCount = typeof watchCmd === "string" ? 2 : 1;
+        cmdArgs = args.filter((_, i) => i < watchFlagIndex || i >= watchFlagIndex + watchArgCount);
     }
+    const targetDir = cmdArgs[0] ?? process.cwd();
+    const sdkDir = path.resolve(__dirname, "..", "..");
+    debugSync({
+        targetDir,
+        sdkDir,
+        watch: watchCmd,
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -120,6 +120,7 @@
     "@types/react-dom": "^19.1.2",
     "@types/react-is": "^19.0.0",
     "@vitejs/plugin-react": "^4.3.4",
+    "chokidar": "^3.6.0",
     "debug": "^4.4.0",
     "enhanced-resolve": "^5.18.1",
     "eventsource-parser": "^3.0.0",
@@ -134,6 +135,7 @@
     "magic-string": "^0.30.17",
     "miniflare": "^4.20250405.0",
     "picocolors": "^1.1.1",
+    "proper-lockfile": "^4.1.2",
     "puppeteer-core": "^22.8.1",
     "react": "19.2.0-canary-39cad7af-20250411",
     "react-dom": "19.2.0-canary-39cad7af-20250411",
@@ -154,6 +156,7 @@
     "@types/debug": "^4.1.12",
     "@types/lodash": "^4.17.16",
     "@types/node": "^22.14.0",
+    "@types/proper-lockfile": "^4.1.4",
     "semver": "^7.7.1",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",