effect-start 0.32.0 → 0.34.0

package/src/bun/BunRoute.ts

@@ -1,5 +1,4 @@
 import * as Bun from "bun"
-import * as NPath from "node:path"
 import * as Data from "effect/Data"
 import * as Either from "effect/Either"
 import * as Effect from "effect/Effect"
@@ -87,54 +86,21 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
         let status = 200
         let contentType = "text/html;charset=utf-8"
 
-        if (bundleDepth === 0) {
-          const bunServer = yield* BunServer.BunServer
-          const url = new URL(originalRequest.url)
-
-          const internalPath = `${bunPrefix}${url.pathname}`
-          const internalUrl = new URL(internalPath, bunServer.server.url)
-
-          const headers = new Headers(originalRequest.headers)
-          headers.set(INTERNAL_FETCH_HEADER, "true")
-
-          const proxyRequest = new Request(internalUrl, {
-            method: originalRequest.method,
-            headers,
-          })
-
-          const response = yield* Effect.tryPromise({
-            try: () => fetch(proxyRequest),
-            catch: (error) =>
-              new BunRouteError({
-                reason: "ProxyError",
-                pattern: internalPath,
-                message: `Failed to fetch internal HTML bundle: ${String(error)}`,
-              }),
-          })
-
-          html = yield* Effect.tryPromise({
-            try: () => response.text(),
-            catch: (error) =>
-              new BunRouteError({
-                reason: "ProxyError",
-                pattern: internalPath,
-                message: String(error),
-              }),
-          })
-          status = response.status
-          contentType = response.headers.get("content-type") ?? contentType
-        } else {
-          html = yield* readBundleHtml(bunLoad).pipe(
-            Effect.mapError(
-              (error) =>
-                new BunRouteError({
-                  reason: "ProxyError",
-                  pattern: bunPrefix,
-                  message: `Failed to load nested HTML bundle: ${String(error)}`,
-                }),
-            ),
-          )
-        }
+        const response = yield* fetchBundleResponse(
+          bunPrefix,
+          originalRequest,
+        )
+        html = yield* Effect.tryPromise({
+          try: () => response.text(),
+          catch: (error) =>
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: bunPrefix,
+              message: String(error),
+            }),
+        })
+        status = response.status
+        contentType = response.headers.get("content-type") ?? contentType
 
         const childEntity = yield* next(context).pipe(
           Effect.locally(bundleDepthRef, bundleDepth + 1),
@@ -162,7 +128,7 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
           }
         }
 
-        childrenHtml = yield* stripInjectedBunScripts(childrenHtml)
+        childrenHtml = yield* stripDuplicateBunScripts(html, childrenHtml)
 
         html = html.replaceAll("%children%", childrenHtml)
 
@@ -186,60 +152,82 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
   }
 }
 
-function stripInjectedBunScripts(html: string) {
-  let removeNextInlineScript = false
-  const rewriter = new HTMLRewriter().on("script", {
-    element(element) {
-      const src = element.getAttribute("src")
-      const hasDevAttribute = element.getAttribute("data-bun-dev-server-script") !== null
-
-      if (hasDevAttribute || (src !== null && src.startsWith("/_bun/client/"))) {
-        element.remove()
-        removeNextInlineScript = true
-        return
-      }
+function fetchBundleResponse(
+  bunPrefix: string,
+  originalRequest: Request,
+) {
+  return Effect.gen(function* () {
+    const bunServer = yield* BunServer.BunServer
+    const url = new URL(originalRequest.url)
+    const internalUrl = new URL(bunServer.server.url)
+
+    internalUrl.pathname = `${bunPrefix}${url.pathname}`
+    internalUrl.search = url.search
+
+    const headers = new Headers(originalRequest.headers)
+    headers.set(INTERNAL_FETCH_HEADER, "true")
+
+    const proxyRequest = new Request(internalUrl, {
+      method: originalRequest.method,
+      headers,
+    })
+
+    return yield* Effect.tryPromise({
+      try: () => fetch(proxyRequest),
+      catch: (error) =>
+        new BunRouteError({
+          reason: "ProxyError",
+          pattern: internalUrl.pathname,
+          message: `Failed to fetch internal HTML bundle: ${String(error)}`,
+        }),
+    })
+  })
+}
 
-      if (removeNextInlineScript && src === null) {
-        element.remove()
-        removeNextInlineScript = false
-        return
+function stripDuplicateBunScripts(parentHtml: string, childHtml: string) {
+  return getInjectedBunScriptSrcs(parentHtml).pipe(
+    Effect.flatMap((parentScriptSrcs) => {
+      if (parentScriptSrcs.size === 0) {
+        return Effect.succeed(childHtml)
       }
 
-      removeNextInlineScript = false
-    },
-  })
+      let removeNextInlineScript = false
+      const rewriter = new HTMLRewriter().on("script", {
+        element(element) {
+          const src = element.getAttribute("src")
+          const hasDevAttribute = element.hasAttribute("data-bun-dev-server-script")
 
-  return Effect.tryPromise({
-    try: () => rewriter.transform(new Response(html)).text(),
-    catch: (error) =>
-      new BunRouteError({
-        reason: "ProxyError",
-        pattern: "stripInjectedBunScripts",
-        message: String(error),
-      }),
-  })
-}
+          if (src !== null && hasDevAttribute && parentScriptSrcs.has(src)) {
+            element.remove()
+            removeNextInlineScript = true
+            return
+          }
+
+          if (removeNextInlineScript && src === null) {
+            element.remove()
+            removeNextInlineScript = false
+            return
+          }
+
+          removeNextInlineScript = false
+        },
+      })
 
-function readBundleHtml(bunLoad: () => Promise<Bun.HTMLBundle>) {
-  return Effect.tryPromise({
-    try: () => bunLoad(),
-    catch: (error) =>
-      new BunRouteError({
-        reason: "ProxyError",
-        pattern: "readBundleHtml",
-        message: String(error),
-      }),
-  }).pipe(
-    Effect.andThen((bundle) => {
-      const indexPath = NPath.isAbsolute(bundle.index)
-        ? bundle.index
-        : NPath.resolve(NPath.dirname(Bun.main), bundle.index)
       return Effect.tryPromise({
-        try: () => Bun.file(indexPath).text(),
+        try: () =>
+          rewriter
+            .transform(
+              new Response(childHtml, {
+                headers: {
+                  "content-type": "text/html;charset=utf-8",
+                },
+              }),
+            )
+            .text(),
         catch: (error) =>
           new BunRouteError({
             reason: "ProxyError",
-            pattern: indexPath,
+            pattern: "stripDuplicateBunScripts",
             message: String(error),
           }),
       })
@@ -247,6 +235,40 @@ function readBundleHtml(bunLoad: () => Promise<Bun.HTMLBundle>) {
   )
 }
 
+function getInjectedBunScriptSrcs(html: string) {
+  return Effect.tryPromise({
+    try: async () => {
+      const srcs = new Set<string>()
+      const rewriter = new HTMLRewriter().on("script", {
+        element(element) {
+          const src = element.getAttribute("src")
+          if (src !== null && element.hasAttribute("data-bun-dev-server-script")) {
+            srcs.add(src)
+          }
+        },
+      })
+
+      await rewriter
+        .transform(
+          new Response(html, {
+            headers: {
+              "content-type": "text/html;charset=utf-8",
+            },
+          }),
+        )
+        .text()
+
+      return srcs
+    },
+    catch: (error) =>
+      new BunRouteError({
+        reason: "ProxyError",
+        pattern: "getInjectedBunScriptSrcs",
+        message: String(error),
+      }),
+  })
+}
+
 type BunServerFetchHandler = (
   request: Request,
   server: Bun.Server<unknown>,

package/src/bun/BunServer.ts

@@ -6,6 +6,7 @@ import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
 import * as Layer from "effect/Layer"
+import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
 import type * as Scope from "effect/Scope"
@@ -43,7 +44,7 @@ interface BunServeOptions {
   readonly reusePort?: boolean
   readonly ipv6Only?: boolean
   readonly idleTimeout?: number
-  readonly development?: boolean
+  readonly development?: Bun.Serve.Development
 }
 
 export type BunServer = {
@@ -145,9 +146,15 @@ export const make = (
     // @ts-expect-error
     service.server = server
 
+    const myFiber = MutableRef.get(PlatformRuntime.mainFiber)
     yield* Effect.addFinalizer(() =>
       Effect.sync(() => {
-        server.stop()
+        // Only stop the server on real shutdown; and not on hot reloads
+        // when Bun.serve automatically swaps routes without restarting the server
+        const currentMain = MutableRef.get(PlatformRuntime.mainFiber)
+        if (currentMain === myFiber) {
+          server.stop()
+        }
       }),
     )
 

package/src/datastar/README.md

@@ -9,15 +9,31 @@ We can probably cut it down by another ~10kb if we remove DataStar expression an
 We made following changes:
 
 - Path aliases converted to relative imports: `@engine/*` → `./engine/*`, etc.
-- Flattened `plugins/` directory: `plugins/actions/` → `actions/`, etc.
-- Deleted the `ALIAS` type declaration: removed `globals.d.ts`,
-  no alias conditional in `utils/text.ts` & `applyAttributePlugin` in `engine.ts`.
+- Flattened and merged the source tree:
+  - `plugins/actions|attributes|watchers` → `actions|attributes|watchers`
+  - `engine/{consts,types,signals,engine}.ts` → `engine.ts`
+  - `utils/{dom,math,paths,polyfills,tags,text,timing,view-transitions}.ts` → `utils.ts`
+- Replaced upstream `bundles/` entrypoints with local `index.ts`:
+  - Registers all plugins as side effects
+  - Re-exports all of `engine.ts` instead of upstream's narrower bundle export surface
+- Removed alias build support:
+  - Deleted `globals.d.ts`
+  - `aliasify()` always produces `data-${name}`
+  - `applyAttributePlugin` no longer accepts aliased `data-${ALIAS}-*` attributes
 - Removed plugin header comments.
 - Updated type declaration to conform to `erasableSyntaxOnly`:
   - Converted `enum ReactiveFlags` and `enum EffectFlags` to `const` objects with `as const`
   - Added type aliases `ReactiveFlags_X` to replace `ReactiveFlags.X` namespace types
-- Extends expressions with function form handled by `genRx`
-- `data-on` supports function form with optional config object:
-  - Function form: `data-on:click="(e) => { e.signals.count.value++ }"`
-  - Function form with config: `data-on:click="(e) => {...}, { debounce: 500, prevent: true }"`
-  - !! `__` attribute modifiers are no longer parsed by `on.ts` (now removed from imports)
+- Extended expressions with function form handled by `genRx`:
+  - Function expressions are evaluated directly instead of compiled through Datastar's string-expression transform
+  - Function expressions receive a `DataEvent` object with `signals`, `actions`, `target`, and `window`
+  - Shared expression-event setup is centralized in `createDataEvent()` and reused by both `genRx` and `data-computed`
+  - Value-returning object literals are compiled as `return ({...});` so block-bodied arrow functions inside object expressions still parse
+- `data-computed` supports object values with function leaves:
+  - String/object-literal form still works: `data-computed="{statusText: (e) => e.signals.state}"`
+  - JSX object form also works: `data-computed={{ statusText: (e) => e.signals.state }}`
+  - Object values only accept functions at the leaves
+  - JSX typing allows `data-computed` object values
+- `data-on` supports function form:
+  - Function form: `data-on:click="(e) => { e.signals.count = e.signals.count + 1 }"`
+  - Event names are used literally from the attribute key; upstream `modifyCasing(..., "kebab")` normalization is no longer applied

package/src/datastar/attributes/computed.ts

@@ -1,4 +1,4 @@
-import { attribute, computed, mergePatch, mergePaths } from "../engine.ts"
+import { attribute, computed, createDataEvent, mergePatch, mergePaths } from "../engine.ts"
 import { modifyCasing, updateLeaves } from "../utils.ts"
 
 attribute({
@@ -7,14 +7,14 @@ attribute({
     value: "must",
   },
   returnsValue: true,
-  apply({ key, mods, rx, error }) {
+  apply({ el, key, mods, rx, error }) {
     if (key) {
       mergePaths([[modifyCasing(key, mods), computed(rx)]])
     } else {
       const patch = Object.assign({}, rx() as Record<string, () => any>)
       updateLeaves(patch, (old) => {
         if (typeof old === "function") {
-          return computed(old)
+          return computed(() => old(createDataEvent({ el, cleanups: new Map(), error: () => error })))
         } else {
           throw error("ComputedExpectedFunction")
         }

package/src/datastar/attributes/on.ts

@@ -4,59 +4,33 @@ import {
   DATASTAR_FETCH_EVENT,
   DATASTAR_SIGNAL_PATCH_EVENT,
   endBatch,
-  type Modifiers,
 } from "../engine.ts"
 import { modifyTiming, modifyViewTransition } from "../utils.ts"
 
-// TODO: support leading/trailing options for debounce/throttle
-// e.g. { debounce: { ms: 500, leading: true, noTrailing: true } }
-const configToMods = (config: Record<string, any>): Modifiers => {
-  const mods: Modifiers = new Map()
-  for (const [k, v] of Object.entries(config)) {
-    if (v === true) {
-      mods.set(k, new Set())
-    } else if (typeof v === "number") {
-      mods.set(k, new Set([`${v}ms`]))
-    }
-  }
-  return mods
-}
-
 attribute({
   name: "on",
   requirement: "must",
   argNames: ["evt"],
-  apply({ el, key, mods, rx, value }) {
-    let userFn: Function | undefined
-    let effectiveMods = mods
-
-    try {
-      const parts = Function(`return [${value}]`)()
-      if (typeof parts[0] === "function") {
-        userFn = parts[0]
-        if (parts[1]) effectiveMods = configToMods(parts[1])
-      }
-    } catch {}
-
+  apply({ el, key, mods, rx }) {
     let target: Element | Window | Document = el
-    if (effectiveMods.has("window")) target = window
+    if (mods.has("window")) target = window
     let callback = (evt?: Event) => {
       if (evt) {
-        if (effectiveMods.has("prevent")) evt.preventDefault()
-        if (effectiveMods.has("stop")) evt.stopPropagation()
+        if (mods.has("prevent")) evt.preventDefault()
+        if (mods.has("stop")) evt.stopPropagation()
       }
       beginBatch()
-      userFn ? userFn(evt) : rx(evt)
+      rx(evt)
       endBatch()
     }
-    callback = modifyViewTransition(callback, effectiveMods)
-    callback = modifyTiming(callback, effectiveMods)
+    callback = modifyViewTransition(callback, mods)
+    callback = modifyTiming(callback, mods)
     const evtListOpts: AddEventListenerOptions = {
-      capture: effectiveMods.has("capture"),
-      passive: effectiveMods.has("passive"),
-      once: effectiveMods.has("once"),
+      capture: mods.has("capture"),
+      passive: mods.has("passive"),
+      once: mods.has("once"),
     }
-    if (effectiveMods.has("outside")) {
+    if (mods.has("outside")) {
       target = document
       const cb = callback
       callback = (evt?: Event) => {

package/src/datastar/engine.ts

@@ -1,3 +1,4 @@
+import type { DataEvent as _DataEvent, HTMLOrSVG as _HTMLOrSVG } from "./types.d.ts"
 import { aliasify, hasOwn, isHTMLOrSVG, isPojo, pathToObj, snake } from "./utils.ts"
 
 /*********
@@ -115,13 +116,42 @@ export type MergePatchArgs = {
   ifMissing?: boolean
 }
 
-export type HTMLOrSVG = HTMLElement | SVGElement | MathMLElement
+export type HTMLOrSVG = _HTMLOrSVG
+export type DataEvent = _DataEvent
 
-export type DataEvent = Event & {
-  signals: Record<string, any>
-  actions: Record<string, (...args: Array<any>) => any>
-  target: HTMLOrSVG
-  window: Window & typeof globalThis
+export const createDataEvent = ({
+  el,
+  evt,
+  cleanups,
+  error,
+}: {
+  el: HTMLOrSVG
+  evt?: Event
+  cleanups: Map<string, () => void>
+  error: (actionName: string) => ErrorFn
+}): DataEvent => {
+  const actionsProxy = new Proxy({} as Record<string, any>, {
+    get:
+      (_, name: string) =>
+      (...actionArgs: Array<any>) => {
+        const err = error(name)
+        const fn = actions[name]
+        if (fn) {
+          return fn({ el, evt: undefined, error: err, cleanups }, ...actionArgs)
+        }
+        throw err("UndefinedAction")
+      },
+  })
+
+  const dataEvt = (evt instanceof Event ? evt : new Event("datastar:expression")) as DataEvent
+  Object.defineProperties(dataEvt, {
+    target: { value: el },
+    signals: { value: root },
+    actions: { value: actionsProxy },
+    window: { value: window },
+  })
+
+  return dataEvt
 }
 
 export type Modifiers = Map<string, Set<string>>
@@ -1092,6 +1122,7 @@ const applyAttributePlugin = (
   const { pluginName, key, mods } = parseAttributeKey(rawKey)
   const plugin = attributePlugins.get(pluginName)
   if ((!onlyNew || queuedAttributeNames.has(pluginName)) && plugin) {
+    const cleanups = new Map<string, () => void>()
     const ctx = {
       el,
       rawKey,
@@ -1147,7 +1178,6 @@ const applyAttributePlugin = (
       }
     }
 
-    const cleanups = new Map<string, () => void>()
     if (valueProvided) {
       let cachedRx: GenRxFn
       ctx.rx = (...args: Array<any>) => {
@@ -1199,27 +1229,16 @@ const genRx = (
     const userFn = Function(`return (${value.trim()})`)()
 
     return (el: HTMLOrSVG, ...args: Array<any>) => {
-      const actionsProxy = new Proxy({} as Record<string, any>, {
-        get:
-          (_, name: string) =>
-          (...actionArgs: Array<any>) => {
-            const err = error.bind(0, {
-              plugin: { type: "action", name },
-              element: { id: el.id, tag: el.tagName },
-              expression: { fnContent: value, value },
-            })
-            const fn = actions[name]
-            if (fn) return fn({ el, evt: undefined, error: err, cleanups }, ...actionArgs)
-            throw err("UndefinedAction")
-          },
-      })
-
-      const dataEvt = args[0] instanceof Event ? args[0] : new Event("datastar:expression")
-      Object.defineProperties(dataEvt, {
-        target: { value: el },
-        signals: { value: root },
-        actions: { value: actionsProxy },
-        window: { value: window },
+      const dataEvt = createDataEvent({
+        el,
+        evt: args[0],
+        cleanups,
+        error: (name) =>
+          error.bind(0, {
+            plugin: { type: "action", name },
+            element: { id: el.id, tag: el.tagName },
+            expression: { fnContent: value, value },
+          }),
       })
 
       try {
@@ -1240,16 +1259,21 @@ const genRx = (
 
   let expr = ""
   if (returnsValue) {
-    const statementRe =
-      /(\/(\\\/|[^/])*\/|"(\\"|[^"])*"|'(\\'|[^'])*'|`(\\`|[^`])*`|\(\s*((function)\s*\(\s*\)|(\(\s*\))\s*=>)\s*(?:\{[\s\S]*?\}|[^;){]*)\s*\)\s*\(\s*\)|[^;])+/gm
-    const statements = value.trim().match(statementRe)
-    if (statements) {
-      const lastIdx = statements.length - 1
-      const last = statements[lastIdx].trim()
-      if (!last.startsWith("return")) {
-        statements[lastIdx] = `return (${last});`
+    const trimmed = value.trim()
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      expr = `return (${trimmed});`
+    } else {
+      const statementRe =
+        /(\/(\\\/|[^/])*\/|"(\\"|[^"])*"|'(\\'|[^'])*'|`(\\`|[^`])*`|\(\s*((function)\s*\(\s*\)|(\(\s*\))\s*=>)\s*(?:\{[\s\S]*?\}|[^;){]*)\s*\)\s*\(\s*\)|[^;])+/gm
+      const statements = trimmed.match(statementRe)
+      if (statements) {
+        const lastIdx = statements.length - 1
+        const last = statements[lastIdx].trim()
+        if (!last.startsWith("return")) {
+          statements[lastIdx] = `return (${last});`
+        }
+        expr = statements.join(";\n")
       }
-      expr = statements.join(";\n")
     }
   } else {
     expr = value.trim()

package/src/datastar/jsx.d.ts

@@ -1,4 +1,4 @@
-import type { DataEvent } from "./engine.ts"
+import type { DataEvent } from "./types.d.ts"
 
 // Datastar object types for specific attributes
 type DatastarSignalsObject = Record<string, any>
@@ -8,21 +8,6 @@ type DatastarStyleObject = Record<string, string | number | boolean | null | und
 
 type DatastarFn = (e: DataEvent) => any
 
-// TODO: support leading/trailing options
-// e.g. { debounce: { ms: 500, leading: true, noTrailing: true } }
-type DatastarOnConfig = {
-  prevent?: boolean
-  stop?: boolean
-  capture?: boolean
-  passive?: boolean
-  once?: boolean
-  outside?: boolean
-  window?: boolean
-  viewTransition?: boolean
-} & ({ debounce?: number; throttle?: never } | { debounce?: never; throttle?: number })
-
-type DatastarOnFn = DatastarFn | [handler: DatastarFn, config: DatastarOnConfig]
-
 /**
  * Datastar attributes for reactive web applications
  * @see https://data-star.dev/reference/attributes
@@ -41,15 +26,16 @@ export interface DatastarAttributes {
 
   // Attributes that accept function expressions
   "data-bind"?: string | undefined
-  "data-computed"?: string | DatastarFn | undefined
+  "data-computed"?: string | DatastarFn | Record<string, DatastarFn | Record<string, DatastarFn>> | undefined
   "data-effect"?: string | DatastarFn | undefined
+  "data-init"?: string | DatastarFn | undefined
   "data-indicator"?: string | undefined
-  "data-json-signals"?: string | undefined
-  "data-on"?: string | DatastarOnFn | undefined
-  "data-on-intersect"?: string | DatastarOnFn | undefined
-  "data-on-interval"?: string | DatastarOnFn | undefined
-  "data-on-load"?: string | DatastarOnFn | undefined
-  "data-on-signal-patch"?: string | DatastarOnFn | undefined
+  "data-json-signals"?: true | string | undefined
+  "data-on"?: string | DatastarFn | undefined
+  "data-on-intersect"?: string | DatastarFn | undefined
+  "data-on-interval"?: string | DatastarFn | undefined
+  "data-on-load"?: string | DatastarFn | undefined
+  "data-on-signal-patch"?: string | DatastarFn | undefined
   "data-on-signal-patch-filter"?: string | undefined
   "data-preserve-attr"?: string | undefined
   "data-ref"?: string | undefined
@@ -58,8 +44,8 @@ export interface DatastarAttributes {
   // Pro attributes
   "data-animate"?: string | undefined
   "data-custom-validity"?: string | DatastarFn | undefined
-  "data-on-raf"?: string | DatastarOnFn | undefined
-  "data-on-resize"?: string | DatastarOnFn | undefined
+  "data-on-raf"?: string | DatastarFn | undefined
+  "data-on-resize"?: string | DatastarFn | undefined
   "data-persist"?: string | undefined
   "data-query-string"?: string | undefined
   "data-replace-url"?: string | undefined
@@ -75,5 +61,5 @@ export interface DatastarAttributes {
   [key: `data-computed:${string}`]: string | DatastarFn | undefined
   [key: `data-indicator:${string}`]: string | undefined
   [key: `data-ref:${string}`]: string | undefined
-  [key: `data-on:${string}`]: string | DatastarOnFn | undefined
+  [key: `data-on:${string}`]: string | DatastarFn | undefined
 }

package/src/datastar/types.d.ts

@@ -0,0 +1,8 @@
+export type HTMLOrSVG = HTMLElement | SVGElement | MathMLElement
+
+export type DataEvent = Event & {
+  signals: Record<string, any>
+  actions: Record<string, (...args: Array<any>) => any>
+  target: HTMLOrSVG
+  window: Window & typeof globalThis
+}