rwsdk 1.0.0-beta.27-test.20251116215153 → 1.0.0-beta.28

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

@@ -1,8 +1,14 @@
 import { CheckConstraintNode, Expression, ForeignKeyConstraintBuilder, PrimaryKeyConstraintNode, sql, UniqueConstraintNode } from "kysely";
 import { AddColumnOp, AlterColumnOp, AlterOperation, DropColumnOp, ExecutedBuilder, ModifyColumnOp, RenameColumnOp, SqlToTsType } from "../utils";
 import { AlterColumnBuilderCallback } from "./alterColumn";
-import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { ColumnDefinitionBuilder, ColumnDescriptor } from "./columnDefinition";
 type DataTypeExpression = string | typeof sql;
+type InitialDescriptor<TType> = {
+    tsType: TType;
+    isNullable: true;
+    hasDefault: false;
+    isAutoIncrement: false;
+};
 interface CheckConstraintBuilder {
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): CheckConstraintNode;
@@ -31,14 +37,18 @@ export interface AlterTableBuilder<TName extends string, TOps extends AlterOpera
         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>]>;
+    addColumn<K extends string, T extends DataTypeExpression>(name: K, type: T): AlterTableBuilder<TName, [
+        ...TOps,
+        AddColumnOp<K, T, InitialDescriptor<SqlToTsType<T>>>
+    ]>;
+    addColumn<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor>(name: K, type: T, build: (col: ColumnDefinitionBuilder<InitialDescriptor<SqlToTsType<T>>>) => ColumnDefinitionBuilder<TDescriptor>): AlterTableBuilder<TName, [...TOps, AddColumnOp<K, T, TDescriptor>]>;
     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>]>;
+    modifyColumn<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<InitialDescriptor<SqlToTsType<T>>>) => ColumnDefinitionBuilder<TDescriptor>): AlterTableBuilder<TName, [...TOps, ModifyColumnOp<K, T, TDescriptor>]>;
     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>;

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

@@ -1,25 +1,39 @@
 import { ColumnDefinitionNode, Expression, sql } from "kysely";
 type DefaultValueExpression = string | number | boolean | null | ReturnType<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>;
+export type ColumnDescriptor = {
+    tsType: any;
+    isNullable: boolean;
+    hasDefault: boolean;
+    isAutoIncrement: boolean;
+};
+export interface ColumnDefinitionBuilder<TDescriptor extends ColumnDescriptor> {
+    autoIncrement(): ColumnDefinitionBuilder<{
+        [K in keyof TDescriptor]: K extends "isAutoIncrement" ? true : TDescriptor[K];
+    }>;
+    identity(): ColumnDefinitionBuilder<TDescriptor>;
+    primaryKey(): ColumnDefinitionBuilder<{
+        [K in keyof TDescriptor]: K extends "isNullable" ? false : TDescriptor[K];
+    }>;
+    references(ref: string): ColumnDefinitionBuilder<TDescriptor>;
+    onDelete(onDelete: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TDescriptor>;
+    onUpdate(onUpdate: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TDescriptor>;
+    unique(): ColumnDefinitionBuilder<TDescriptor>;
+    notNull(): ColumnDefinitionBuilder<{
+        [K in keyof TDescriptor]: K extends "isNullable" ? false : TDescriptor[K];
+    }>;
+    unsigned(): ColumnDefinitionBuilder<TDescriptor>;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder<{
+        [K in keyof TDescriptor]: K extends "isNullable" ? false : K extends "hasDefault" ? true : TDescriptor[K];
+    }>;
+    check(expression: Expression<any>): ColumnDefinitionBuilder<TDescriptor>;
+    generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder<TDescriptor>;
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder<TDescriptor>;
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder<TDescriptor>;
+    stored(): ColumnDefinitionBuilder<TDescriptor>;
+    modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder<TDescriptor>;
+    nullsNotDistinct(): ColumnDefinitionBuilder<TDescriptor>;
+    ifNotExists(): ColumnDefinitionBuilder<TDescriptor>;
+    modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder<TDescriptor>;
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): ColumnDefinitionNode;
 }

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

@@ -1,6 +1,6 @@
 import { CheckConstraintNode, CompiledQuery, CreateTableNode, Expression, ForeignKeyConstraintBuilder, PrimaryKeyConstraintNode, UniqueConstraintNode } from "kysely";
 import { ExecutedBuilder, Prettify, SqlToTsType } from "../utils";
-import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { ColumnDefinitionBuilder, ColumnDescriptor } from "./columnDefinition";
 interface CheckConstraintBuilder {
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): CheckConstraintNode;
@@ -22,13 +22,20 @@ interface PrimaryKeyConstraintBuilder {
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): PrimaryKeyConstraintNode;
 }
+type InitialDescriptor<TType> = {
+    tsType: TType;
+    isNullable: true;
+    hasDefault: false;
+    isAutoIncrement: false;
+};
 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 extends Record<string, any> ? TSchema : {}) & Record<K, SqlToTsType<T>>>>;
+    addColumn<K extends string, T extends string>(name: K, type: T): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, InitialDescriptor<SqlToTsType<T>>>>>;
+    addColumn<K extends string, T extends string, TDescriptor extends ColumnDescriptor>(name: K, type: T, build: (col: ColumnDefinitionBuilder<InitialDescriptor<SqlToTsType<T>>>) => ColumnDefinitionBuilder<TDescriptor>): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, TDescriptor>>>;
     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>;

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

@@ -1,9 +1,10 @@
-import { Kysely } from "kysely";
+import { Generated, Kysely } from "kysely";
 import { AlterTableBuilder } from "./builders/alterTable";
 import { CreateTableBuilder } from "./builders/createTable";
 import { DropTableBuilder } from "./builders/dropTable";
 import { SchemaBuilder } from "./builders/schema";
 import { ExecutedBuilder, Prettify, ProcessAlteredTable, UnionToTuple } from "./utils";
+import { ColumnDescriptor } from "./builders/columnDefinition";
 export interface InferenceBuilder {
     schema: SchemaBuilder;
 }
@@ -23,5 +24,18 @@ type ApplyBuilders<TSchema, TBuildersTuple> = TBuildersTuple extends [
     ...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>>;
+type TableToSelectType<TTable> = Prettify<{
+    [K in keyof TTable]: TTable[K] extends ColumnDescriptor ? TTable[K]["isNullable"] extends true ? TTable[K]["tsType"] | null : TTable[K]["tsType"] : TTable[K];
+}>;
+type TableToKyselySchema<TTable> = Prettify<{
+    [K in keyof TTable]: TTable[K] extends ColumnDescriptor ? TTable[K]["hasDefault"] extends true ? Generated<TTable[K]["isNullable"] extends true ? TTable[K]["tsType"] | null : TTable[K]["tsType"]> : TTable[K]["isAutoIncrement"] extends true ? Generated<TTable[K]["tsType"]> : TTable[K]["isNullable"] extends true ? TTable[K]["tsType"] | null : TTable[K]["tsType"] : TTable[K];
+}>;
+type DatabaseWithDescriptors<TMigrations extends Migrations = Migrations> = ProcessMigrations<TMigrations, UnionToTuple<keyof TMigrations>>;
+export type Database<TMigrations extends Migrations = Migrations> = Prettify<{
+    [K in keyof DatabaseWithDescriptors<TMigrations>]: TableToSelectType<DatabaseWithDescriptors<TMigrations>[K]>;
+} & {
+    __kyselySchema: {
+        [K in keyof DatabaseWithDescriptors<TMigrations>]: TableToKyselySchema<DatabaseWithDescriptors<TMigrations>[K]>;
+    };
+}>;
 export {};

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

@@ -97,7 +97,7 @@
             },
         },
     };
-    //(_test: Expect<Equal<Actual, Expected>>) => {};
+    //(_test: ExpectDb<Actual, Expected>) => {};
 };
 (_it = "alterTable addUniqueConstraint") => {
     const migrations = {
@@ -123,7 +123,7 @@
             },
         },
     };
-    //(_test: Expect<Equal<Actual, Expected>>) => {};
+    //(_test: ExpectDb<Actual, Expected>) => {};
 };
 (_it = "alterTable drop column") => {
     const migrations = {
@@ -153,7 +153,7 @@
             up: async (db) => [
                 await db.schema
                     .createTable("users")
-                    .addColumn("id", "integer")
+                    .addColumn("id", "integer", (c) => c.primaryKey().autoIncrement())
                     .execute(),
             ],
         },
@@ -242,7 +242,7 @@
                 return [
                     await db.schema
                         .createTable("users")
-                        .addColumn("id", "integer")
+                        .addColumn("id", "integer", (col) => col.notNull())
                         .execute(),
                 ];
             },
@@ -271,7 +271,7 @@
                 return [
                     await db.schema
                         .createTable("users")
-                        .addColumn("id", "integer")
+                        .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
                         .execute(),
                 ];
             },
@@ -357,4 +357,79 @@
     };
     (_test) => { };
 };
+(_it = "alterTable addColumn with notNull") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer", (col) => col.primaryKey())
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .addColumn("email", "text", (col) => col.notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable modifyColumn with notNull") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("products")
+                        .addColumn("price", "real")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("products")
+                        .modifyColumn("price", "real", (col) => col.notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable modifyColumn nullable to non-nullable") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("orders")
+                        .addColumn("status", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("orders")
+                        .modifyColumn("status", "text", (col) => col.notNull().defaultTo("pending"))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
 export {};

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

@@ -22,9 +22,11 @@ import { sql } from "kysely";
                     await db.schema
                         .createTable("users")
                         .addColumn("username", "text", (col) => col.notNull())
-                        .addColumn("age", "integer", (col) => col.defaultTo(18))
                         .addColumn("active", "boolean", (col) => col.defaultTo(true))
                         .addColumn("anotherBoolean", "boolean", (col) => col.defaultTo(sql `true`))
+                        .addColumn("email", "text", (col) => col)
+                        .addColumn("favoriteColor", "text", (col) => col.unique())
+                        .addColumn("name", "text", (col) => col.defaultTo("John Doe"))
                         .execute(),
                 ];
             },
@@ -32,3 +34,102 @@ import { sql } from "kysely";
     };
     (_test) => { };
 };
+(_it = "createTable column without callback is nullable") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("posts")
+                        .addColumn("title", "text")
+                        .addColumn("body", "text")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "createTable with primaryKey is non-nullable") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer", (col) => col.primaryKey())
+                        .addColumn("email", "text", (col) => col.notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "createTable with unique but no notNull is nullable") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("products")
+                        .addColumn("sku", "text", (col) => col.unique())
+                        .addColumn("name", "text", (col) => col)
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "defaultTo makes columns non-nullable in Database type") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("status", "text", (col) => col.defaultTo("active"))
+                        .addColumn("count", "integer", (col) => col.defaultTo(0))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+// --- Insert/Update Type Tests ---
+(_it = "makes autoIncrement columns optional on insert") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
+                        .addColumn("username", "text", (col) => col.notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    const db = {};
+    db.insertInto("users").values({ username: "test" });
+};
+(_it = "makes defaultTo columns optional on insert") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull())
+                        .addColumn("status", "text", (col) => col.notNull().defaultTo("active"))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    const db = {};
+    db.insertInto("users").values({ username: "test" });
+};

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

@@ -1,2 +1,3 @@
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export type Expect<T extends true> = T;
+export type OmitInternals<T> = Omit<T, "__kyselySchema">;

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

@@ -1,9 +1,11 @@
 import { sql } from "kysely";
+import { ColumnDescriptor } from "./builders/columnDefinition";
 type DataTypeExpression = string | typeof sql;
-export type AddColumnOp<K extends string, T extends DataTypeExpression> = {
+export type AddColumnOp<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor> = {
     op: "addColumn";
     name: K;
     type: T;
+    descriptor: TDescriptor;
 };
 export type DropColumnOp<K extends string> = {
     op: "dropColumn";
@@ -14,10 +16,11 @@ export type RenameColumnOp<KFrom extends string, KTo extends string> = {
     from: KFrom;
     to: KTo;
 };
-export type ModifyColumnOp<K extends string, T extends DataTypeExpression> = {
+export type ModifyColumnOp<K extends string, T extends DataTypeExpression, TDescriptor extends ColumnDescriptor> = {
     op: "modifyColumn";
     name: K;
     type: T;
+    descriptor: TDescriptor;
 };
 export type Alteration = {
     kind: "setDataType";
@@ -37,7 +40,7 @@ export type AlterColumnOp<K extends string, TAlteration extends Alteration> = {
     name: K;
     alteration: TAlteration;
 };
-export type AlterOperation = AddColumnOp<any, any> | DropColumnOp<any> | RenameColumnOp<any, any> | AlterColumnOp<any, any> | ModifyColumnOp<any, any>;
+export type AlterOperation = AddColumnOp<any, any, any> | DropColumnOp<any> | RenameColumnOp<any, any> | AlterColumnOp<any, any> | ModifyColumnOp<any, 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];
@@ -57,17 +60,64 @@ 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>;
+type ApplyOp<TSchema, THeadOp> = THeadOp extends AddColumnOp<infer K, any, infer TDescriptor> ? Prettify<TSchema & {
+    [P in K]: TDescriptor;
 }> : 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 {
+}> : TSchema : THeadOp extends AlterColumnOp<infer K, infer TAlt> ? K extends keyof TSchema ? 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>;
+    [P in K]: {
+        tsType: SqlToTsType<DT>;
+        isNullable: TSchema[K] extends {
+            isNullable: infer N;
+        } ? N : true;
+        hasDefault: TSchema[K] extends {
+            hasDefault: infer D;
+        } ? D : false;
+        isAutoIncrement: TSchema[K] extends {
+            isAutoIncrement: infer A;
+        } ? A : false;
+    };
+}> : TAlt extends {
+    kind: "setDefault";
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TSchema[K] extends ColumnDescriptor ? {
+        tsType: TSchema[K]["tsType"];
+        isNullable: false;
+        hasDefault: true;
+        isAutoIncrement: TSchema[K]["isAutoIncrement"];
+    } : TSchema[K];
+}> : TAlt extends {
+    kind: "dropDefault";
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TSchema[K] extends ColumnDescriptor ? {
+        tsType: TSchema[K]["tsType"];
+        isNullable: TSchema[K]["isNullable"];
+        hasDefault: false;
+        isAutoIncrement: TSchema[K]["isAutoIncrement"];
+    } : TSchema[K];
+}> : TAlt extends {
+    kind: "setNotNull";
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TSchema[K] extends ColumnDescriptor ? {
+        tsType: TSchema[K]["tsType"];
+        isNullable: false;
+        hasDefault: TSchema[K]["hasDefault"];
+        isAutoIncrement: TSchema[K]["isAutoIncrement"];
+    } : TSchema[K];
+}> : TAlt extends {
+    kind: "dropNotNull";
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TSchema[K] extends ColumnDescriptor ? {
+        tsType: TSchema[K]["tsType"];
+        isNullable: true;
+        hasDefault: TSchema[K]["hasDefault"];
+        isAutoIncrement: TSchema[K]["isAutoIncrement"];
+    } : TSchema[K];
+}> : TSchema : TSchema : THeadOp extends ModifyColumnOp<infer K, any, infer TDescriptor> ? Prettify<Omit<TSchema, K> & {
+    [P in K]: TDescriptor;
 }> : TSchema;
 /**
  * Recursively processes a list of alteration operations (AST)

package/dist/runtime/lib/stitchDocumentAndAppStreams.d.ts

@@ -15,4 +15,70 @@
  * @param startMarker The marker in the document to start injecting the app.
  * @param endMarker The marker in the app stream that signals the end of the initial, non-suspended render.
  */
+/**
+ * A utility that orchestrates and interleaves three ReadableStreams to produce a
+ * single, valid HTML response stream. It uses two special markers:
+ *
+ * - `startMarker`: Placed in the `outerHtml` stream (the document shell) to
+ *   designate where the application's content should be injected.
+ * - `endMarker`: Injected into the `innerHtml` stream's RSC payload to signal
+ *   the end of the initial, non-suspended render. This marker is needed for
+ *   non-blocking hydration, as it allows the stitching process to send the
+ *   client `<script>` tags before all suspended content has resolved.
+ *
+ * It manages three main stream readers:
+ *
+ * - `hoistedTagsReader`: Reads from the `hoistedTagsStream`, which contains only
+ *   the hoisted meta tags (e.g., `<title>`, `<meta>`).
+ * - `outerReader`: Reads from the `outerHtml` stream, which is the server-rendered
+ *   document shell (containing `<html>`, `<head>`, etc.).
+ * - `innerReader`: Reads from the `appBodyStream`, which contains the main
+ *   application content, stripped of its hoisted tags.
+ *
+ * The function proceeds through a multi-phase state machine, managed by the
+ * `pump` function, to correctly interleave these streams.
+ *
+ * The state machine moves through the following phases:
+ *
+ * 1. `read-hoisted`:
+ *    - **Goal:** Buffer all hoisted tags from the `hoistedTagsStream`.
+ *    - **Action:** Reads from `hoistedTagsReader` and appends all content into
+ *      the `hoistedTagsBuffer`. Does not enqueue anything yet.
+ *    - **Transition:** Moves to `outer-head` when the stream is exhausted.
+ *
+ * 2. `outer-head`:
+ *    - **Goal:** Stream the document up to the closing `</head>` tag, inject the
+ *      hoisted tags, and then continue until the app `startMarker`.
+ *    - **Action:** Reads from `outerReader`. When it finds `</head>`, it enqueues
+ *      the content before it, then enqueues the `hoistedTagsBuffer`, and finally
+ *      enqueues the `</head>` tag itself. It then continues reading from
+ *      `outerReader` until it finds the `startMarker`.
+ *    - **Transition:** Moves to `inner-shell` after finding and discarding the
+ *      `startMarker`.
+ *
+ * 3. `inner-shell`:
+ *    - **Goal:** Stream the initial, non-suspended part of the application.
+ *    - **Action:** Switches to `innerReader`. It enqueues chunks until it finds
+ *      the `endMarker`. Any content after the marker is stored in
+ *      `innerSuspendedRemains`.
+ *    - **Transition:** Moves to `outer-tail` after finding the `endMarker`.
+ *
+ * 4. `outer-tail`:
+ *    - **Goal:** Stream the rest of the document's `<body>`, including client
+ *      `<script>` tags.
+ *    - **Action:** Switches back to `outerReader` and enqueues chunks until it
+ *      finds the `</body>` tag.
+ *    - **Transition:** Moves to `inner-suspended` after finding `</body>`.
+ *
+ * 5. `inner-suspended`:
+ *    - **Goal:** Stream any suspended content from the React app.
+ *    - **Action:** First enqueues any content from `innerSuspendedRemains`, then
+ *      continues reading from `innerReader` until the stream is exhausted.
+ *    - **Transition:** Moves to `outer-end` when the stream is exhausted.
+ *
+ * 6. `outer-end`:
+ *    - **Goal:** Finish the document.
+ *    - **Action:** Switches back to `outerReader` for the last time to send the
+ *      closing `</body>` and `</html>` tags.
+ */
 export declare function stitchDocumentAndAppStreams(outerHtml: ReadableStream<Uint8Array>, innerHtml: ReadableStream<Uint8Array>, startMarker: string, endMarker: string): ReadableStream<Uint8Array>;

package/dist/runtime/lib/stitchDocumentAndAppStreams.js

@@ -105,6 +105,72 @@ function splitStreamOnFirstNonHoistedTag(sourceStream) {
     });
     return [hoistedTagsStream, appBodyStream];
 }
+/**
+ * A utility that orchestrates and interleaves three ReadableStreams to produce a
+ * single, valid HTML response stream. It uses two special markers:
+ *
+ * - `startMarker`: Placed in the `outerHtml` stream (the document shell) to
+ *   designate where the application's content should be injected.
+ * - `endMarker`: Injected into the `innerHtml` stream's RSC payload to signal
+ *   the end of the initial, non-suspended render. This marker is needed for
+ *   non-blocking hydration, as it allows the stitching process to send the
+ *   client `<script>` tags before all suspended content has resolved.
+ *
+ * It manages three main stream readers:
+ *
+ * - `hoistedTagsReader`: Reads from the `hoistedTagsStream`, which contains only
+ *   the hoisted meta tags (e.g., `<title>`, `<meta>`).
+ * - `outerReader`: Reads from the `outerHtml` stream, which is the server-rendered
+ *   document shell (containing `<html>`, `<head>`, etc.).
+ * - `innerReader`: Reads from the `appBodyStream`, which contains the main
+ *   application content, stripped of its hoisted tags.
+ *
+ * The function proceeds through a multi-phase state machine, managed by the
+ * `pump` function, to correctly interleave these streams.
+ *
+ * The state machine moves through the following phases:
+ *
+ * 1. `read-hoisted`:
+ *    - **Goal:** Buffer all hoisted tags from the `hoistedTagsStream`.
+ *    - **Action:** Reads from `hoistedTagsReader` and appends all content into
+ *      the `hoistedTagsBuffer`. Does not enqueue anything yet.
+ *    - **Transition:** Moves to `outer-head` when the stream is exhausted.
+ *
+ * 2. `outer-head`:
+ *    - **Goal:** Stream the document up to the closing `</head>` tag, inject the
+ *      hoisted tags, and then continue until the app `startMarker`.
+ *    - **Action:** Reads from `outerReader`. When it finds `</head>`, it enqueues
+ *      the content before it, then enqueues the `hoistedTagsBuffer`, and finally
+ *      enqueues the `</head>` tag itself. It then continues reading from
+ *      `outerReader` until it finds the `startMarker`.
+ *    - **Transition:** Moves to `inner-shell` after finding and discarding the
+ *      `startMarker`.
+ *
+ * 3. `inner-shell`:
+ *    - **Goal:** Stream the initial, non-suspended part of the application.
+ *    - **Action:** Switches to `innerReader`. It enqueues chunks until it finds
+ *      the `endMarker`. Any content after the marker is stored in
+ *      `innerSuspendedRemains`.
+ *    - **Transition:** Moves to `outer-tail` after finding the `endMarker`.
+ *
+ * 4. `outer-tail`:
+ *    - **Goal:** Stream the rest of the document's `<body>`, including client
+ *      `<script>` tags.
+ *    - **Action:** Switches back to `outerReader` and enqueues chunks until it
+ *      finds the `</body>` tag.
+ *    - **Transition:** Moves to `inner-suspended` after finding `</body>`.
+ *
+ * 5. `inner-suspended`:
+ *    - **Goal:** Stream any suspended content from the React app.
+ *    - **Action:** First enqueues any content from `innerSuspendedRemains`, then
+ *      continues reading from `innerReader` until the stream is exhausted.
+ *    - **Transition:** Moves to `outer-end` when the stream is exhausted.
+ *
+ * 6. `outer-end`:
+ *    - **Goal:** Finish the document.
+ *    - **Action:** Switches back to `outerReader` for the last time to send the
+ *      closing `</body>` and `</html>` tags.
+ */
 export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, endMarker) {
     const [hoistedTagsStream, appBodyStream] = splitStreamOnFirstNonHoistedTag(innerHtml);
     const decoder = new TextDecoder();
@@ -115,138 +181,211 @@ export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, e
     let buffer = "";
     let outerBufferRemains = "";
     let innerSuspendedRemains = "";
-    let phase = "enqueue-hoisted";
+    let hoistedTagsBuffer = "";
+    let hoistedTagsReady = false;
+    let phase = "read-hoisted";
     const pump = async (controller) => {
+        const enqueue = (text) => {
+            if (text) {
+                controller.enqueue(encoder.encode(text));
+            }
+        };
+        const flush = () => {
+            const flushIndex = buffer.lastIndexOf("\n");
+            if (flushIndex !== -1) {
+                enqueue(buffer.slice(0, flushIndex + 1));
+                buffer = buffer.slice(flushIndex + 1);
+            }
+        };
         try {
-            if (phase === "enqueue-hoisted") {
+            if (phase === "read-hoisted") {
+                // Continuously read from the hoisted tags stream and buffer the
+                // content. Once the stream is finished, transition to the next phase.
                 const { done, value } = await hoistedTagsReader.read();
+                // When the stream is done, we're ready to process the document head.
                 if (done) {
+                    hoistedTagsReady = true;
                     phase = "outer-head";
                 }
                 else {
-                    controller.enqueue(value);
+                    // Otherwise, keep appending to the buffer.
+                    hoistedTagsBuffer += decoder.decode(value, { stream: true });
                 }
             }
             else if (phase === "outer-head") {
+                // Read from the document stream. Search for the closing `</head>` tag
+                // to inject the buffered hoisted tags. Then, search for the
+                // `startMarker` to know when to start injecting the app shell. Once
+                // the marker is found, transition to the next phase.
                 const { done, value } = await outerReader.read();
+                // Handle the case where the document stream ends.
                 if (done) {
+                    // If there's content left in the buffer, process it for markers.
                     if (buffer) {
+                        const headCloseIndex = buffer.indexOf("</head>");
+                        if (headCloseIndex !== -1 &&
+                            hoistedTagsReady &&
+                            hoistedTagsBuffer) {
+                            enqueue(buffer.slice(0, headCloseIndex));
+                            enqueue(hoistedTagsBuffer);
+                            hoistedTagsBuffer = "";
+                            enqueue("</head>");
+                            buffer = buffer.slice(headCloseIndex + "</head>".length);
+                        }
                         const markerIndex = buffer.indexOf(startMarker);
                         if (markerIndex !== -1) {
-                            controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                            enqueue(buffer.slice(0, markerIndex));
                             outerBufferRemains = buffer.slice(markerIndex + startMarker.length);
                         }
                         else {
-                            controller.enqueue(encoder.encode(buffer));
+                            enqueue(buffer);
                         }
                         buffer = "";
                     }
+                    else if (hoistedTagsReady && hoistedTagsBuffer) {
+                        enqueue(hoistedTagsBuffer);
+                        hoistedTagsBuffer = "";
+                    }
+                    // Even if the stream ends, we must proceed to the app shell phase.
                     phase = "inner-shell";
                 }
                 else {
+                    // As chunks arrive, append them to the buffer.
                     buffer += decoder.decode(value, { stream: true });
+                    // Search for the closing head tag to inject hoisted tags.
+                    const headCloseIndex = buffer.indexOf("</head>");
+                    if (headCloseIndex !== -1 && hoistedTagsReady && hoistedTagsBuffer) {
+                        enqueue(buffer.slice(0, headCloseIndex));
+                        enqueue(hoistedTagsBuffer);
+                        hoistedTagsBuffer = "";
+                        enqueue("</head>");
+                        buffer = buffer.slice(headCloseIndex + "</head>".length);
+                    }
+                    // Search for the start marker to switch to the app stream.
                     const markerIndex = buffer.indexOf(startMarker);
                     if (markerIndex !== -1) {
-                        controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                        enqueue(buffer.slice(0, markerIndex));
                         outerBufferRemains = buffer.slice(markerIndex + startMarker.length);
                         buffer = "";
                         phase = "inner-shell";
                     }
                     else {
-                        const flushIndex = buffer.lastIndexOf("\n");
-                        if (flushIndex !== -1) {
-                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
-                            buffer = buffer.slice(flushIndex + 1);
-                        }
+                        // If no marker is found yet, flush the buffer up to the last
+                        // newline to keep the stream flowing.
+                        flush();
                     }
                 }
             }
             else if (phase === "inner-shell") {
+                // Now read from the app stream. We send the initial part of the app
+                // content until we find the `endMarker`. This marker tells us that the
+                // non-suspended part of the app is rendered. Any content after this
+                // marker is considered suspended and is buffered. Then, transition.
                 const { done, value } = await innerReader.read();
+                // Handle the case where the app stream ends.
                 if (done) {
                     if (buffer)
-                        controller.enqueue(encoder.encode(buffer));
+                        enqueue(buffer);
                     phase = "outer-tail";
                 }
                 else {
+                    // As chunks arrive, append them to the buffer.
                     buffer += decoder.decode(value, { stream: true });
                     const markerIndex = buffer.indexOf(endMarker);
+                    // If the end marker is found, enqueue content up to the marker,
+                    // buffer the rest, and switch to the document tail phase.
                     if (markerIndex !== -1) {
                         const endOfMarkerIndex = markerIndex + endMarker.length;
-                        controller.enqueue(encoder.encode(buffer.slice(0, endOfMarkerIndex)));
+                        enqueue(buffer.slice(0, endOfMarkerIndex));
                         innerSuspendedRemains = buffer.slice(endOfMarkerIndex);
                         buffer = "";
                         phase = "outer-tail";
                     }
                     else {
-                        const flushIndex = buffer.lastIndexOf("\n");
-                        if (flushIndex !== -1) {
-                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
-                            buffer = buffer.slice(flushIndex + 1);
-                        }
+                        // If no marker is found yet, flush the buffer.
+                        flush();
                     }
                 }
             }
             else if (phase === "outer-tail") {
+                // Switch back to the document stream. The goal is to send the rest of
+                // the document's body, which critically includes the client-side
+                // `<script>` tags for hydration. We stream until we find the closing
+                // `</body>` tag and then transition.
+                // First, process any leftover buffer from the `outer-head` phase.
                 if (outerBufferRemains) {
                     buffer = outerBufferRemains;
                     outerBufferRemains = "";
                 }
                 const { done, value } = await outerReader.read();
+                // Handle the case where the document stream ends.
                 if (done) {
                     if (buffer) {
+                        // Search the remaining buffer for the closing body tag.
                         const markerIndex = buffer.indexOf("</body>");
                         if (markerIndex !== -1) {
-                            controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                            enqueue(buffer.slice(0, markerIndex));
                             buffer = buffer.slice(markerIndex);
                         }
                         else {
-                            controller.enqueue(encoder.encode(buffer));
+                            enqueue(buffer);
                             buffer = "";
                         }
                     }
+                    // Proceed to the suspended content phase.
                     phase = "inner-suspended";
                 }
                 else {
+                    // As chunks arrive, append them to the buffer.
                     buffer += decoder.decode(value, { stream: true });
+                    // Search for the closing body tag to switch to suspended content.
                     const markerIndex = buffer.indexOf("</body>");
                     if (markerIndex !== -1) {
-                        controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                        enqueue(buffer.slice(0, markerIndex));
                         buffer = buffer.slice(markerIndex);
                         phase = "inner-suspended";
                     }
                     else {
-                        const flushIndex = buffer.lastIndexOf("\n");
-                        if (flushIndex !== -1) {
-                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
-                            buffer = buffer.slice(flushIndex + 1);
-                        }
+                        // If no marker is found yet, flush the buffer.
+                        flush();
                     }
                 }
             }
             else if (phase === "inner-suspended") {
+                // Switch back to the app stream. First, send any buffered suspended
+                // content from the `inner-shell` phase. Then, stream the rest of the
+                // app content until it's finished. This is all the content that was
+                // behind a `<Suspense>` boundary.
+                // First, send any buffered suspended content from the `inner-shell` phase.
                 if (innerSuspendedRemains) {
-                    controller.enqueue(encoder.encode(innerSuspendedRemains));
+                    enqueue(innerSuspendedRemains);
                     innerSuspendedRemains = "";
                 }
                 const { done, value } = await innerReader.read();
+                // When the app stream is done, transition to the final phase.
                 if (done) {
                     phase = "outer-end";
                 }
                 else {
+                    // Otherwise, pass through the remaining app content directly.
                     controller.enqueue(value);
                 }
             }
             else if (phase === "outer-end") {
+                // Finally, switch back to the document stream one last time to send
+                // the closing `</body>` and `</html>` tags and finish the response.
+                // First, send any leftover buffer from the `outer-tail` phase.
                 if (buffer) {
-                    controller.enqueue(encoder.encode(buffer));
+                    enqueue(buffer);
                     buffer = "";
                 }
                 const { done, value } = await outerReader.read();
+                // When the document stream is done, we're finished.
                 if (done) {
                     controller.close();
                     return;
                 }
+                // Otherwise, pass through the final document content.
                 controller.enqueue(value);
             }
             await pump(controller);

package/dist/runtime/lib/stitchDocumentAndAppStreams.test.js

@@ -45,7 +45,7 @@ describe("stitchDocumentAndAppStreams", () => {
     const startMarker = '<div id="rwsdk-app-start" />';
     const endMarker = '<div id="rwsdk-app-end"></div>';
     describe("meta tag hoisting", () => {
-        it("extracts and prepends single title tag", async () => {
+        it("places hoisted tags inside head, after existing head content", async () => {
             const outerHtml = `<!DOCTYPE html>
 <html>
 <head>
@@ -59,10 +59,19 @@ describe("stitchDocumentAndAppStreams", () => {
             const innerHtml = `<title>Page Title</title><div>App content</div>${endMarker}`;
             const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
             expect(result).toContain(`<title>Page Title</title>`);
-            expect(result.indexOf(`<title>Page Title</title>`)).toBeLessThan(result.indexOf(`<!DOCTYPE html>`));
+            expect(result).toMatch(/<head>[\s\S]*<meta charset="utf-8" \/>[\s\S]*<title>Page Title<\/title>[\s\S]*<\/head>/);
             expect(result).toContain(`<div>App content</div>`);
+            const doctypeIndex = result.indexOf(`<!DOCTYPE html>`);
+            const headIndex = result.indexOf(`<head>`);
+            const charsetIndex = result.indexOf(`<meta charset="utf-8" />`);
+            const titleIndex = result.indexOf(`<title>Page Title</title>`);
+            const headCloseIndex = result.indexOf(`</head>`);
+            expect(doctypeIndex).toBe(0);
+            expect(doctypeIndex).toBeLessThan(headIndex);
+            expect(charsetIndex).toBeLessThan(titleIndex);
+            expect(titleIndex).toBeLessThan(headCloseIndex);
         });
-        it("extracts and prepends multiple hoisted tags", async () => {
+        it("places multiple hoisted tags inside head, after existing head content", async () => {
             const outerHtml = `<!DOCTYPE html>
 <html>
 <head>
@@ -78,9 +87,14 @@ describe("stitchDocumentAndAppStreams", () => {
             expect(result).toContain(`<title>Page Title</title>`);
             expect(result).toContain(`<meta name="description" content="Test" />`);
             expect(result).toContain(`<link rel="stylesheet" href="/styles.css" />`);
-            const hoistedStart = result.indexOf(`<title>Page Title</title>`);
-            const doctypeStart = result.indexOf(`<!DOCTYPE html>`);
-            expect(hoistedStart).toBeLessThan(doctypeStart);
+            expect(result).toMatch(/<head>[\s\S]*<meta charset="utf-8" \/>[\s\S]*<title>Page Title<\/title>[\s\S]*<meta name="description" content="Test" \/>[\s\S]*<link rel="stylesheet" href="\/styles.css" \/>[\s\S]*<\/head>/);
+            const doctypeIndex = result.indexOf(`<!DOCTYPE html>`);
+            const charsetIndex = result.indexOf(`<meta charset="utf-8" />`);
+            const titleIndex = result.indexOf(`<title>Page Title</title>`);
+            const headCloseIndex = result.indexOf(`</head>`);
+            expect(doctypeIndex).toBe(0);
+            expect(charsetIndex).toBeLessThan(titleIndex);
+            expect(titleIndex).toBeLessThan(headCloseIndex);
         });
         it("handles app stream with no hoisted tags", async () => {
             const outerHtml = `<!DOCTYPE html>
@@ -117,9 +131,29 @@ describe("stitchDocumentAndAppStreams", () => {
             const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), createChunkedStream(innerHtmlChunks), startMarker, endMarker));
             expect(result).toContain(`<title>Page Title</title>`);
             expect(result).toContain(`<meta name="description" content="Test" />`);
-            const hoistedStart = result.indexOf(`<title>Page Title</title>`);
-            const doctypeStart = result.indexOf(`<!DOCTYPE html>`);
-            expect(hoistedStart).toBeLessThan(doctypeStart);
+            expect(result).toMatch(/<head>[\s\S]*<meta charset="utf-8" \/>[\s\S]*<title>Page Title<\/title>[\s\S]*<\/head>/);
+            const doctypeIndex = result.indexOf(`<!DOCTYPE html>`);
+            const charsetIndex = result.indexOf(`<meta charset="utf-8" />`);
+            const titleIndex = result.indexOf(`<title>Page Title</title>`);
+            const headCloseIndex = result.indexOf(`</head>`);
+            expect(doctypeIndex).toBe(0);
+            expect(charsetIndex).toBeLessThan(titleIndex);
+            expect(titleIndex).toBeLessThan(headCloseIndex);
+        });
+        it("ensures doctype is always first", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<title>Page Title</title><div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result.trim().startsWith(`<!DOCTYPE html>`)).toBe(true);
         });
     });
     describe("basic stitching flow", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.27-test.20251116215153",
+  "version": "1.0.0-beta.28",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {