effect-start 0.9.0 → 0.10.0

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "effect-start",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "license": "MIT",
   "exports": {
     ".": "./src/index.ts",
     "./Router": "./src/Router.ts",
     "./Route": "./src/Route.ts",
-    "./Datastar": "./src/Datastar.ts",
     "./EncryptedCookies": "./src/EncryptedCookies.ts",
     "./bun": "./src/bun/index.ts",
     "./client": "./src/client/index.ts",
@@ -20,14 +19,14 @@
   },
   "scripts": {
     "format": "bunx dprint fmt",
+    "test": "bun test src/",
     "deploy": "bunx npm publish --access public"
   },
   "dependencies": {
-    "@effect/platform": ">=0.82",
-    "@effect/platform-bun": ">=0.65"
+    "@effect/platform": "^0.93.3"
   },
   "peerDependencies": {
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.3",
     "effect": ">=3.16.4"
   },
   "peerDependenciesMeta": {
@@ -39,15 +38,15 @@
     "@dprint/json": "^0.21.0",
     "@dprint/markdown": "^0.20.0",
     "@dprint/typescript": "^0.95.12",
-    "@effect/language-service": "^0.23.3",
-    "@tailwindcss/node": ">=4.1.8",
-    "@types/bun": "^1.2.15",
-    "@types/react": "^19.1.6",
-    "@types/react-dom": "^19.1.6",
-    "dprint-cli": "^0.4.0",
+    "@effect/language-service": "^0.56.0",
+    "@tailwindcss/node": "^4.1.17",
+    "@types/bun": "^1.3.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "dprint-cli": "^0.4.1",
     "dprint-markup": "nounder/dprint-markup",
-    "effect": "^3.19.4",
-    "effect-memfs": "nounder/effect-memfs#a976bb0",
+    "effect": "^3.19.6",
+    "effect-memfs": "^0.8.0",
     "ts-namespace-import": "nounder/ts-namespace-import#140c405"
   },
   "files": [

package/src/BundleHttp.test.ts

@@ -15,7 +15,7 @@ import * as BunBundle from "./bun/BunBundle.ts"
 const effect = effectFn(
   Layer.effect(
     Bundle.ClientBundle,
-    BunBundle.buildClient(IndexHtml),
+    BunBundle.buildClient(IndexHtml as any),
   ),
 )
 

package/src/Commander.test.ts

@@ -3,7 +3,7 @@ import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
 import * as Commander from "./Commander.ts"
 
-t.describe("make", () => {
+t.describe(`${Commander.make.name}`, () => {
   t.it("should create a basic command", () => {
     const cmd = Commander.make({
       name: "test-app",
@@ -14,7 +14,7 @@ t.describe("make", () => {
   })
 })
 
-t.describe("option - nested builder API", () => {
+t.describe(`${Commander.option.name} - nested builder API`, () => {
   t.it("should add an option with schema", () => {
     const cmd = Commander
       .make({ name: "app" })
@@ -76,7 +76,7 @@ t.describe("option - nested builder API", () => {
   })
 })
 
-t.describe("parse - kebab-to-camel conversion", () => {
+t.describe(`${Commander.parse.name} - kebab-to-camel conversion`, () => {
   t.it("should convert kebab-case to camelCase", async () => {
     const cmd = Commander
       .make({ name: "app" })
@@ -198,7 +198,7 @@ t.describe("parse - kebab-to-camel conversion", () => {
   })
 })
 
-t.describe("optionHelp", () => {
+t.describe(`${Commander.optionHelp.name}`, () => {
   t.it("should add help option", () => {
     const cmd = Commander
       .make({ name: "app" })
@@ -210,7 +210,7 @@ t.describe("optionHelp", () => {
   })
 })
 
-t.describe("optionVersion", () => {
+t.describe(`${Commander.optionVersion.name}`, () => {
   t.it("should add version option", () => {
     const cmd = Commander
       .make({ name: "app", version: "1.0.0" })
@@ -222,7 +222,7 @@ t.describe("optionVersion", () => {
   })
 })
 
-t.describe("handle", () => {
+t.describe(`${Commander.handle.name}`, () => {
   t.it("should mark command as handled", () => {
     const handled = Commander
       .make({ name: "app" })
@@ -246,7 +246,7 @@ t.describe("handle", () => {
   })
 })
 
-t.describe("subcommand", () => {
+t.describe(`${Commander.subcommand.name}`, () => {
   t.it("should add subcommand", () => {
     const subCmd = Commander
       .make({ name: "format" })
@@ -266,7 +266,7 @@ t.describe("subcommand", () => {
   })
 })
 
-t.describe("help", () => {
+t.describe(`${Commander.help.name}`, () => {
   t.it("should generate help text", () => {
     const cmd = Commander
       .make({
@@ -309,7 +309,7 @@ t.describe("BooleanFromString", () => {
   })
 })
 
-t.describe("choice", () => {
+t.describe(`${Commander.choice.name}`, () => {
   t.it("should accept valid choice", async () => {
     const ColorSchema = Schema.compose(
       Schema.String,
@@ -337,7 +337,7 @@ t.describe("choice", () => {
   })
 })
 
-t.describe("repeatable", () => {
+t.describe(`${Commander.repeatable.name}`, () => {
   t.it("should parse comma-separated values", async () => {
     const schema = Commander.repeatable(Schema.String)
 
@@ -452,7 +452,7 @@ t.describe("integration", () => {
   })
 })
 
-t.describe("parse - comprehensive", () => {
+t.describe(`${Commander.parse.name} - comprehensive`, () => {
   t.it("should parse with explicit args", async () => {
     const cmd = Commander
       .make({ name: "app" })
@@ -845,7 +845,7 @@ t.describe("action/handler", () => {
   })
 })
 
-t.describe("version", () => {
+t.describe(`${Commander.optionVersion.name} - version behavior`, () => {
   t.it("should include version in command definition", () => {
     const cmd = Commander
       .make({ name: "app", version: "1.0.0" })
@@ -860,7 +860,7 @@ t.describe("version", () => {
       .make({ name: "app", version: "2.0.0" })
 
     t.expect(cmd.version).toBe("2.0.0")
-    t.expect((cmd.options as any).version).toBeUndefined()
+    t.expect(cmd.options["version"]).toBeUndefined()
   })
 
   t.it("should include version option in help", () => {
@@ -875,7 +875,7 @@ t.describe("version", () => {
   })
 })
 
-t.describe("help - comprehensive", () => {
+t.describe(`${Commander.help.name} - comprehensive`, () => {
   t.it("should generate help with description", () => {
     const cmd = Commander
       .make({
@@ -951,7 +951,7 @@ t.describe("help - comprehensive", () => {
   })
 })
 
-t.describe("subcommands - comprehensive", () => {
+t.describe(`${Commander.subcommand.name} - comprehensive`, () => {
   t.it("should add subcommand", () => {
     const subCmd = Commander
       .make({ name: "build" })

package/src/Commander.ts

@@ -172,6 +172,19 @@ export interface SubcommandDef<Handled extends boolean = boolean> {
   readonly command: CommanderSet<any, any, Handled>
 }
 
+type Extend<
+  S,
+  NewOpts extends OptionsMap,
+  NewSubs extends ReadonlyArray<SubcommandDef> = [],
+  Handled extends boolean = false,
+> = S extends CommanderSet<infer Opts, infer Subs, infer _H> ? CommanderSet<
+    & Opts
+    & NewOpts,
+    [...Subs, ...NewSubs],
+    Handled
+  >
+  : CommanderSet<NewOpts, NewSubs, Handled>
+
 type CommanderBuilder = {
   option: typeof optionMethod
   optionHelp: typeof optionHelp
@@ -222,26 +235,13 @@ const optionMethod = function<
 >(
   this: S,
   opt: Opt,
-): S extends CommanderSet<infer Opts, infer Subs, infer _H> ? CommanderSet<
-    & Opts
-    & {
-      [K in Opt["name"] as OptionNameToCamelCase<K>]: Opt
-    },
-    Subs,
-    false
-  >
-  : CommanderSet<
-    {
-      [K in Opt["name"] as OptionNameToCamelCase<K>]: Opt
-    },
-    [],
-    false
+): Extend<S, { [K in Opt["name"] as OptionNameToCamelCase<K>]: Opt }> {
+  const base = (this && typeof this === "object" ? this : {}) as Partial<
+    CommanderSet.Instance
   >
-{
-  const base = this && typeof this === "object" ? this as any : {}
-  const baseName = base.name || ""
-  const baseOptions: OptionsMap = base.options || {}
-  const baseSubcommands = base.subcommands || []
+  const baseName = base.name ?? ""
+  const baseOptions: OptionsMap = base.options ?? {}
+  const baseSubcommands = base.subcommands ?? []
   const baseDescription = base.description
   const baseVersion = base.version
 
@@ -253,31 +253,18 @@ const optionMethod = function<
     version: baseVersion,
     options: { ...baseOptions, [camelKey]: opt },
     subcommands: baseSubcommands,
-  }) as any
+  }) as Extend<S, { [K in Opt["name"] as OptionNameToCamelCase<K>]: Opt }>
 }
 
 export const optionHelp = function<S>(
   this: S,
-): S extends CommanderSet<infer Opts, infer Subs, infer _H> ? CommanderSet<
-    & Opts
-    & {
-      "help": OptionBuilder<boolean, "--help">
-    },
-    Subs,
-    false
-  >
-  : CommanderSet<
-    {
-      "help": OptionBuilder<boolean, "--help">
-    },
-    [],
-    false
+): Extend<S, { "help": OptionBuilder<boolean, "--help"> }> {
+  const base = (this && typeof this === "object" ? this : {}) as Partial<
+    CommanderSet.Instance
   >
-{
-  const base = this && typeof this === "object" ? this as any : {}
-  const baseName = base.name || ""
-  const baseOptions: OptionsMap = base.options || {}
-  const baseSubcommands = base.subcommands || []
+  const baseName = base.name ?? ""
+  const baseOptions: OptionsMap = base.options ?? {}
+  const baseSubcommands = base.subcommands ?? []
   const baseDescription = base.description
   const baseVersion = base.version
 
@@ -296,31 +283,18 @@ export const optionHelp = function<S>(
     version: baseVersion,
     options: { ...baseOptions, help: helpOption },
     subcommands: baseSubcommands,
-  }) as any
+  }) as Extend<S, { "help": OptionBuilder<boolean, "--help"> }>
 }
 
 export const optionVersion = function<S>(
   this: S,
-): S extends CommanderSet<infer Opts, infer Subs, infer _H> ? CommanderSet<
-    & Opts
-    & {
-      "version": OptionBuilder<boolean, "--version">
-    },
-    Subs,
-    false
-  >
-  : CommanderSet<
-    {
-      "version": OptionBuilder<boolean, "--version">
-    },
-    [],
-    false
+): Extend<S, { "version": OptionBuilder<boolean, "--version"> }> {
+  const base = (this && typeof this === "object" ? this : {}) as Partial<
+    CommanderSet.Instance
   >
-{
-  const base = this && typeof this === "object" ? this as any : {}
-  const baseName = base.name || ""
-  const baseOptions: OptionsMap = base.options || {}
-  const baseSubcommands = base.subcommands || []
+  const baseName = base.name ?? ""
+  const baseOptions: OptionsMap = base.options ?? {}
+  const baseSubcommands = base.subcommands ?? []
   const baseDescription = base.description
   const baseVersion = base.version
 
@@ -339,7 +313,7 @@ export const optionVersion = function<S>(
     version: baseVersion,
     options: { ...baseOptions, version: versionOption },
     subcommands: baseSubcommands,
-  }) as any
+  }) as Extend<S, { "version": OptionBuilder<boolean, "--version"> }>
 }
 
 export const subcommand = function<
@@ -350,27 +324,19 @@ export const subcommand = function<
 >(
   this: S,
   cmd: CommanderSet<SubOpts, SubSubs, SubHandled>,
-): S extends CommanderSet<infer Opts, infer Subs, infer _H> ? CommanderSet<
-    Opts,
-    [...Subs, SubcommandDef<SubHandled>],
-    false
+): Extend<S, {}, [SubcommandDef<SubHandled>]> {
+  const base = (this && typeof this === "object" ? this : {}) as Partial<
+    CommanderSet.Instance
   >
-  : CommanderSet<
-    {},
-    [SubcommandDef<SubHandled>],
-    false
-  >
-{
-  const base = this && typeof this === "object" ? this as any : {}
-  const baseName = base.name || ""
-  const baseOptions = base.options || {}
-  const baseSubcommands = base.subcommands || []
+  const baseName = base.name ?? ""
+  const baseOptions = base.options ?? {}
+  const baseSubcommands = base.subcommands ?? []
   const baseDescription = base.description
   const baseVersion = base.version
 
-  const subDef: SubcommandDef = {
+  const subDef: SubcommandDef<SubHandled> = {
     _tag: "SubcommandDef",
-    command: cmd as any,
+    command: cmd,
   }
 
   return makeSet({
@@ -378,8 +344,8 @@ export const subcommand = function<
     description: baseDescription,
     version: baseVersion,
     options: baseOptions,
-    subcommands: [...baseSubcommands, subDef] as any,
-  }) as any
+    subcommands: [...baseSubcommands, subDef],
+  }) as Extend<S, {}, [SubcommandDef<SubHandled>]>
 }
 
 export const handle = function<
@@ -389,16 +355,16 @@ export const handle = function<
   this: CommanderSet<Opts, Subs, false>,
   handler: (args: ExtractOptionValues<Opts>) => Effect.Effect<void>,
 ): CommanderSet<Opts, Subs, true> {
-  const base = this && typeof this === "object" ? this as any : {}
+  const base = this as CommanderSet.Instance<Opts, Subs, false>
 
-  return makeSet({
-    name: base.name || "",
+  return makeSet<Opts, Subs, true>({
+    name: base.name,
     description: base.description,
     version: base.version,
-    options: base.options || {},
-    subcommands: base.subcommands || [],
-    handler: handler as any,
-  }) as any
+    options: base.options,
+    subcommands: base.subcommands,
+    handler,
+  })
 }
 
 export const make = <const Name extends string>(config: {
@@ -589,12 +555,16 @@ export const runMain = <
 
     const parsedOptions = yield* parse(cmd, args)
 
-    if ((parsedOptions as any).help) {
+    if (Predicate.hasProperty(parsedOptions, "help") && parsedOptions.help) {
       console.log(generateHelp(cmd))
       return
     }
 
-    if ((parsedOptions as any).version && cmd.version) {
+    if (
+      Predicate.hasProperty(parsedOptions, "version")
+      && parsedOptions.version
+      && cmd.version
+    ) {
       console.log(`${cmd.name} v${cmd.version}`)
       return
     }
@@ -669,4 +639,4 @@ export const repeatable = <A>(
     })
     .pipe(
       Schema.compose(Schema.Array(schema)),
-    ) as any
+    )

package/src/EncryptedCookies.test.ts

@@ -4,7 +4,7 @@ import * as ConfigProvider from "effect/ConfigProvider"
 import * as Effect from "effect/Effect"
 import * as EncryptedCookies from "./EncryptedCookies.ts"
 
-t.describe("encrypt", () => {
+t.describe(`${EncryptedCookies.encrypt.name}`, () => {
   t.test("return encrypted string in correct format", async () => {
     const value = "hello world"
 
@@ -79,7 +79,7 @@ t.describe("encrypt", () => {
   })
 })
 
-t.describe("decrypt", () => {
+t.describe(`${EncryptedCookies.decrypt.name}`, () => {
   t.test("decrypt encrypted string successfully", async () => {
     const originalValue = "hello world"
 
@@ -192,7 +192,7 @@ t.describe("decrypt", () => {
   })
 })
 
-t.describe("encryptCookie", () => {
+t.describe(`${EncryptedCookies.encryptCookie.name}`, () => {
   t.test("preserve cookie properties and encrypt value", async () => {
     const cookie = Cookies.unsafeMakeCookie("test", "hello world")
 
@@ -211,7 +211,7 @@ t.describe("encryptCookie", () => {
   })
 })
 
-t.describe("decryptCookie", () => {
+t.describe(`${EncryptedCookies.decryptCookie.name}`, () => {
   t.test("preserve cookie properties and decrypt value", async () => {
     const originalCookie = Cookies.unsafeMakeCookie("test", "hello world")
 

package/src/FileHttpRouter.test.ts

@@ -17,7 +17,6 @@ class CustomError extends Data.TaggedError("CustomError") {}
 const SampleRoutes = [
   {
     path: "/users",
-    segments: [{ literal: "users" }],
     load: async () => ({
       default: Route
         .html(Effect.succeed("Users list"))
@@ -26,15 +25,14 @@ const SampleRoutes = [
   },
   {
     path: "/articles",
-    segments: [{ literal: "articles" }],
     load: async () => ({
       default: Route.html(Effect.succeed("Articles list")),
     }),
   },
 ] as const
 
-const SampleRouteManifest: Router.RouteManifest = {
-  modules: SampleRoutes,
+const SampleRouteManifest: Router.RouterManifest = {
+  routes: SampleRoutes,
 }
 
 const routerLayer = Router.layerPromise(async () => SampleRouteManifest)
@@ -55,9 +53,8 @@ t.it("HttpRouter Requirement and Error types infers", () =>
 
 t.it("HTTP methods", () =>
   effect(function*() {
-    const allMethodsRoute: Router.ServerRoute = {
+    const allMethodsRoute: Router.LazyRoute = {
       path: "/",
-      segments: [],
       load: async () => ({
         default: Route
           .html(Effect.succeed("GET"))
@@ -90,8 +87,8 @@ t.it("HTTP methods", () =>
 
 t.it("router handles requests correctly", () =>
   effect(function*() {
-    const routerContext = yield* Router.Router
-    const client = TestHttpClient.make(routerContext.httpRouter)
+    const router = yield* FileHttpRouter.make(SampleRoutes)
+    const client = TestHttpClient.make(router)
 
     const getUsersResponse = yield* client.get("/users")
 
@@ -147,24 +144,21 @@ t.it(
   "handles routes with special characters (tilde and hyphen)",
   () =>
     effect(function*() {
-      const specialCharRoutes: Router.ServerRoute[] = [
+      const specialCharRoutes: Router.LazyRoute[] = [
         {
           path: "/api-v1",
-          segments: [{ literal: "api-v1" }],
           load: async () => ({
             default: Route.text(Effect.succeed("API v1")),
           }),
         },
         {
           path: "/files~backup",
-          segments: [{ literal: "files~backup" }],
           load: async () => ({
             default: Route.text(Effect.succeed("Backup files")),
           }),
         },
         {
           path: "/test-route~temp",
-          segments: [{ literal: "test-route~temp" }],
           load: async () => ({
             default: Route.post(Route.text(Effect.succeed("Test route"))),
           }),
@@ -205,3 +199,78 @@ t.it(
         .toBe("Test route")
     }),
 )
+
+t.it(
+  "layer routes can wrap inner routes using next()",
+  () =>
+    effect(function*() {
+      const routeWithLayer: Router.LazyRoute = {
+        path: "/page",
+        load: async () => ({
+          default: Route.html(Effect.succeed("<h1>Page Content</h1>")),
+        }),
+        layers: [
+          async () => ({
+            default: Route.layer(
+              Route.html(function*(context) {
+                const innerContent = yield* context.next()
+                return `<html><body>${innerContent}</body></html>`
+              }),
+            ),
+          }),
+        ],
+      }
+
+      const router = yield* FileHttpRouter.make([routeWithLayer])
+      const client = TestHttpClient.make(router)
+
+      const response = yield* client.get("/page")
+
+      t.expect(response.status).toBe(200)
+
+      const html = yield* response.text
+
+      t.expect(html).toBe("<html><body><h1>Page Content</h1></body></html>")
+    }),
+)
+
+t.it("nested layers compose correctly with next()", () =>
+  effect(function*() {
+    const routeWithNestedLayers: Router.LazyRoute = {
+      path: "/nested",
+      load: async () => ({
+        default: Route.html(Effect.succeed("content")),
+      }),
+      layers: [
+        async () => ({
+          default: Route.layer(
+            Route.html(function*(context) {
+              const inner = yield* context.next()
+              return `<div class="outer">${inner}</div>`
+            }),
+          ),
+        }),
+        async () => ({
+          default: Route.layer(
+            Route.html(function*(context) {
+              const inner = yield* context.next()
+              return `<div class="inner">${inner}</div>`
+            }),
+          ),
+        }),
+      ],
+    }
+
+    const router = yield* FileHttpRouter.make([routeWithNestedLayers])
+    const client = TestHttpClient.make(router)
+
+    const response = yield* client.get("/nested")
+
+    t.expect(response.status).toBe(200)
+
+    const html = yield* response.text
+
+    t.expect(html).toBe(
+      "<div class=\"outer\"><div class=\"inner\">content</div></div>",
+    )
+  }))