effect-start 0.26.0 → 0.28.0

package/src/System.ts

@@ -1,11 +1,69 @@
 import * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
+import * as NNet from "node:net"
 
 import * as ChildProcess from "./ChildProcess.ts"
 import * as PlatformError from "./PlatformError.ts"
 
 export const cwd: Effect.Effect<string> = Effect.sync(() => process.cwd())
 
+export const randomFreePort: Effect.Effect<number, PlatformError.SystemError> = Effect.async<
+  number,
+  PlatformError.SystemError
+>((resume) => {
+  const server = NNet.createServer()
+  server.unref()
+  server.on("error", (err) =>
+    resume(
+      Effect.fail(
+        new PlatformError.SystemError({
+          reason: "Unknown",
+          module: "System",
+          method: "randomFreePort",
+          description: err.message,
+          cause: err,
+        }),
+      ),
+    ),
+  )
+  server.listen(0, "127.0.0.1", () => {
+    const address = server.address()
+    if (!address || typeof address === "string") {
+      server.close(() =>
+        resume(
+          Effect.fail(
+            new PlatformError.SystemError({
+              reason: "Unknown",
+              module: "System",
+              method: "randomFreePort",
+              description: "Failed to allocate a free port",
+            }),
+          ),
+        ),
+      )
+      return
+    }
+    const port = address.port
+    server.close((err) => {
+      if (err) {
+        resume(
+          Effect.fail(
+            new PlatformError.SystemError({
+              reason: "Unknown",
+              module: "System",
+              method: "randomFreePort",
+              description: err.message,
+              cause: err,
+            }),
+          ),
+        )
+        return
+      }
+      resume(Effect.succeed(port))
+    })
+  })
+})
+
 export const which = (name: string): Effect.Effect<string, PlatformError.SystemError> =>
   Effect.flatMap(
     Effect.try({
@@ -33,11 +91,10 @@ export const which = (name: string): Effect.Effect<string, PlatformError.SystemE
   )
 
 export const spawn = (
-  command: string,
-  args?: ReadonlyArray<string>,
+  cmd: readonly [string, ...Array<string>],
   options?: ChildProcess.Command.Options,
 ): Effect.Effect<
   ChildProcess.ChildProcessHandle,
   PlatformError.PlatformError,
   ChildProcess.ChildProcessSpawner | Scope.Scope
-> => ChildProcess.spawn(ChildProcess.make(command, args, options))
+> => ChildProcess.spawn(ChildProcess.make(cmd, options))

package/src/Unique.ts

@@ -4,6 +4,56 @@ export const ALPHABET_BASE64_URL =
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
 export const ALPHABET_HEX = "0123456789abcdef"
 
+interface SnowflakeState {
+  timestampMs: bigint
+  sequence: bigint
+}
+
+interface Snowflake {
+  (): bigint
+  readonly state: SnowflakeState
+  readonly timestamp: (id: bigint) => bigint
+}
+
+function buildSnowflake(): {
+  (): bigint
+  readonly state: SnowflakeState
+  readonly timestamp: (id: bigint) => bigint
+} {
+  const timestampBits = 48n
+  const seqBits = 16n
+  const seqMax = (1n << seqBits) - 1n
+  const timestampMask = (1n << timestampBits) - 1n
+
+  const fn = Object.assign(
+    () => {
+      const nowMs = BigInt(Date.now())
+      const timestampMs = nowMs > fn.state.timestampMs ? nowMs : fn.state.timestampMs
+
+      if (timestampMs > fn.state.timestampMs) {
+        fn.state.timestampMs = timestampMs
+        fn.state.sequence = 0n
+      } else {
+        fn.state.sequence += 1n
+        if (fn.state.sequence > seqMax) {
+          fn.state.timestampMs += 1n
+          fn.state.sequence = 0n
+        }
+      }
+
+      return ((fn.state.timestampMs & timestampMask) << seqBits) | fn.state.sequence
+    },
+    {
+      state: {
+        timestampMs: 0n,
+        sequence: -1n,
+      },
+      timestamp: (id: bigint): bigint => id >> seqBits,
+    },
+  )
+  return fn
+}
+
 /**
  * Generate a random string for ids, session tokens, and API keys.
  * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
@@ -169,6 +219,15 @@ function toSafeTime(time: number): number {
   return Math.max(0, Math.trunc(time))
 }
 
+/**
+ * Monotonic Snowflake variant:
+ * - 48-bit unix timestamp (ms)
+ * - 16-bit sequence
+ * - sequence resets on timestamp increment
+ * - over-capacity sequence carries into next millisecond
+ */
+export const snowflake = buildSnowflake()
+
 /**
  * Generate a nanoid-style random string.
  *

package/src/Values.ts

@@ -73,9 +73,20 @@ export const firstValue = <T>(record: Record<string, T>): T | undefined => {
   return undefined
 }
 
+export const isTemplateStringsArray = (value: unknown): value is TemplateStringsArray =>
+  Array.isArray(value) && "raw" in value
+
 export const concatBytes = (a: Uint8Array, b: Uint8Array): Uint8Array => {
   const result = new Uint8Array(a.byteLength + b.byteLength)
   result.set(a)
   result.set(b, a.byteLength)
   return result
 }
+
+export const compact = (record: Record<string, unknown | undefined>): Record<string, unknown> => {
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(record)) {
+    if (value !== undefined) out[key] = value
+  }
+  return out
+}

package/src/bun/BunChildProcessSpawner.ts

@@ -6,21 +6,14 @@ import type * as BunTypes from "bun"
 import * as ChildProcess from "../ChildProcess.ts"
 import * as PlatformError from "../PlatformError.ts"
 
-const toCmd = (command: ChildProcess.Command): ReadonlyArray<string> => [
-  command.command,
-  ...command.args,
-]
-
 export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succeed(
   ChildProcess.ChildProcessSpawner,
   {
     spawn: (command) =>
       Effect.gen(function* () {
-        const cmd = toCmd(command)
-
         const proc = yield* Effect.try({
           try: () =>
-            Bun.spawn(cmd as Array<string>, {
+            Bun.spawn([...command.cmd], {
               cwd: command.cwd,
               env: command.env,
               stdin: command.stdin ?? "ignore",

package/src/bun/BunRoute.ts

@@ -113,7 +113,7 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
             }),
         })
 
-        const childEntity = yield* Entity.resolve(next(context))
+        const childEntity = yield* next(context)
         const children = childEntity?.body ?? childEntity
 
         let childrenHtml = ""
@@ -156,6 +156,7 @@ type BunServerFetchHandler = (
 
 type BunServerRouteHandler =
   | Bun.HTMLBundle
+  | Bun.BunFile
   | BunServerFetchHandler
   | Partial<Record<Bun.Serve.HTTPMethod, BunServerFetchHandler>>
 

package/src/bun/BunRuntime.ts

@@ -1,25 +1,19 @@
-import type * as Fiber from "effect/Fiber"
-import * as GlobalValue from "effect/GlobalValue"
 import * as MutableRef from "effect/MutableRef"
 import * as PlatformRuntime from "../PlatformRuntime.ts"
 
-const mainFiber = GlobalValue.globalValue(Symbol.for("effect-start/BunRuntime/existingFiber"), () =>
-  MutableRef.make<Fiber.RuntimeFiber<unknown, unknown> | undefined>(undefined),
-)
+export const runMain = PlatformRuntime.makeRunMain((options) => {
+  const prevFiber = MutableRef.get(PlatformRuntime.mainFiber)
 
-export const runMain = PlatformRuntime.makeRunMain(({ fiber, teardown }) => {
-  const prevFiber = MutableRef.get(mainFiber)
-
-  MutableRef.set(mainFiber, fiber)
+  MutableRef.set(PlatformRuntime.mainFiber, options.fiber)
 
   let receivedSignal = false
 
-  fiber.addObserver((exit) => {
+  options.fiber.addObserver((exit) => {
     if (!receivedSignal) {
       process.removeListener("SIGINT", onSigint)
       process.removeListener("SIGTERM", onSigint)
     }
-    teardown(exit, (code) => {
+    options.teardown(exit, (code) => {
       if (receivedSignal || code !== 0) {
         process.exit(code)
       }
@@ -30,7 +24,7 @@ export const runMain = PlatformRuntime.makeRunMain(({ fiber, teardown }) => {
     receivedSignal = true
     process.removeListener("SIGINT", onSigint)
     process.removeListener("SIGTERM", onSigint)
-    fiber.unsafeInterruptAsFork(fiber.id())
+    options.fiber.unsafeInterruptAsFork(options.fiber.id())
   }
 
   process.on("SIGINT", onSigint)

package/src/bun/BunServer.ts

@@ -12,7 +12,7 @@ import type * as Scope from "effect/Scope"
 import * as NOs from "node:os"
 import * as NPath from "node:path"
 import * as PathPattern from "../PathPattern.ts"
-import * as PlataformRuntime from "../PlatformRuntime.ts"
+import * as PlatformRuntime from "../PlatformRuntime.ts"
 import * as Route from "../Route.ts"
 import * as RouteHttp from "../RouteHttp.ts"
 import * as StartApp from "../StartApp.ts"
@@ -60,7 +60,7 @@ export const make = (
   Effect.gen(function* () {
     const port = yield* Config.number("PORT").pipe(
       Effect.catchTag("ConfigError", () => {
-        return PlataformRuntime.isAgentHarness()
+        return PlatformRuntime.isAgentHarness()
           ? Effect.succeed(0) // random port
           : Effect.succeed(3000)
       }),
@@ -228,11 +228,14 @@ function walkBunRoutes(runtime: Runtime.Runtime<BunServer>, tree: RouteTree.Rout
     const pathGroups = new Map<string, Array<RouteMount.MountedRoute>>()
     const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime)
 
+    let hasPrebuiltBundles = false
+
     for (const route of RouteTree.walk(tree)) {
       const bunDescriptors = BunRoute.descriptors(route)
       if (bunDescriptors) {
         const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad)
         if (htmlBundle.files) {
+          hasPrebuiltBundles = true
           registerPrebuiltBundle(bunDescriptors.bunPrefix, htmlBundle, bunRoutes)
         } else {
           bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle
@@ -252,6 +255,15 @@ function walkBunRoutes(runtime: Runtime.Runtime<BunServer>, tree: RouteTree.Rout
       }
     }
 
+    if (hasPrebuiltBundles) {
+      const mainDir = NPath.dirname(Bun.main)
+      for (const output of discoverStaticOutputs(mainDir)) {
+        const routePath = `/${NPath.basename(output.path)}`
+        if (routePath in bunRoutes) continue
+        bunRoutes[routePath] = Bun.file(output.path)
+      }
+    }
+
     return bunRoutes
   })
 }
@@ -274,6 +286,38 @@ function registerPrebuiltBundle(prefix: string, bundle: any, bunRoutes: BunRoute
   }
 }
 
+type StaticOutput = Pick<Bun.BuildArtifact, "path" | "loader" | "kind">
+
+function discoverStaticOutputs(dir: string): Array<StaticOutput> {
+  const loaderByExt: Record<string, Bun.Loader> = {
+    ".js": "js",
+    ".mjs": "js",
+    ".cjs": "js",
+    ".jsx": "jsx",
+    ".tsx": "tsx",
+    ".ts": "ts",
+    ".css": "css",
+    ".html": "html",
+    ".json": "json",
+    ".jsonc": "jsonc",
+    ".toml": "toml",
+    ".yaml": "yaml",
+    ".wasm": "wasm",
+    ".txt": "text",
+  }
+
+  const outputs: Array<StaticOutput> = []
+  for (const entry of new Bun.Glob("*").scanSync({ cwd: dir, onlyFiles: true })) {
+    const ext = NPath.extname(entry).toLowerCase()
+    outputs.push({
+      path: NPath.resolve(dir, entry),
+      loader: loaderByExt[ext] ?? "file",
+      kind: "asset",
+    })
+  }
+  return outputs
+}
+
 function rewriteRelativeAssetPaths(html: string | Promise<string>): Promise<string> {
   const rewriter = new HTMLRewriter()
     .on("link[href]", {
@@ -292,6 +336,14 @@ function rewriteRelativeAssetPaths(html: string | Promise<string>): Promise<stri
         }
       },
     })
+    .on("img[src]", {
+      element(el) {
+        const src = el.getAttribute("src")
+        if (src && isRelativePath(src)) {
+          el.setAttribute("src", "/" + assetBasename(src))
+        }
+      },
+    })
 
   return Promise.resolve(html).then((h) => rewriter.transform(new Response(h)).text())
 }

package/src/datastar/watchers/patchElements.ts

@@ -403,7 +403,6 @@ const removeNode = (node: Node): void => {
 }
 
 const moveBefore: (parentNode: Node, node: Node, after: Node | null) => void =
-  // @ts-expect-error
   removeNode.call.bind(ctxPantry.moveBefore ?? ctxPantry.insertBefore)
 
 const aliasedPreserveAttr = aliasify("preserve-attr")

package/src/hyper/HyperHtml.ts

@@ -53,6 +53,9 @@ let map = {
 
 const RAW_TEXT_TAGS = ["script", "style"]
 
+// Prevents closing html tags in embedded css/js source
+const escapeRawText = (text: string) => text.replaceAll("</", "<\\/")
+
 export function renderToString(
   node: JSX.Children,
   hooks?: { onNode?: (node: HyperNode.HyperNode) => void },
@@ -113,8 +116,7 @@ export function renderToString(
       for (const key in props) {
         if (
           key !== "children" &&
-          key !== "innerHTML" && // Solid-specific
-          key !== "dangerouslySetInnerHTML" && // React-specific
+          key !== "dangerouslySetInnerHTML" &&
           props[key] !== false &&
           props[key] != null
         ) {
@@ -140,17 +142,19 @@ export function renderToString(
       if (!EMPTY_TAGS.includes(type)) {
         stack.push(`</${type}>`)
 
-        const html = props.dangerouslySetInnerHTML?.__html ?? props.innerHTML
+        const isRawText = RAW_TEXT_TAGS.includes(type)
+        const html = props.dangerouslySetInnerHTML?.__html
 
         if (html) {
-          result += html
+          result += isRawText ? escapeRawText(html) : html
         } else {
           const children = props.children
 
           if (type === "script" && typeof children === "function") {
-            result += `(${children.toString()})(window)`
-          } else if (RAW_TEXT_TAGS.includes(type) && children != null) {
-            result += Array.isArray(children) ? children.join("") : children
+            result += escapeRawText(`(${children.toString()})(window)`)
+          } else if (isRawText && children != null) {
+            const raw = Array.isArray(children) ? children.join("") : String(children)
+            result += escapeRawText(raw)
           } else if (Array.isArray(children)) {
             for (let i = children.length - 1; i >= 0; i--) {
               stack.push(children[i])

package/src/hyper/jsx.d.ts

@@ -536,7 +536,7 @@ export namespace JSX {
     // [key: ClassKeys]: boolean;
 
     // properties
-    innerHTML?: string
+    dangerouslySetInnerHTML?: { __html: string }
     textContent?: string | number
 
     // attributes

package/src/lint/plugin.js

@@ -55,15 +55,38 @@ export default {
 
             const typePrefix = node.importKind === "type" ? "type " : ""
 
+            const sourceCode = context.sourceCode || context.getSourceCode()
+
             context.report({
               node,
               messageId: "preferNamespace",
               data: { source, baseName, typePrefix },
               fix(fixer) {
-                return fixer.replaceText(
-                  node,
-                  `import ${typePrefix}* as ${baseName} from "${source}"`,
-                )
+                const fixes = [
+                  fixer.replaceText(node, `import ${typePrefix}* as ${baseName} from "${source}"`),
+                ]
+
+                for (const specifier of node.specifiers) {
+                  if (specifier.type !== "ImportSpecifier") continue
+                  const localName = specifier.local.name
+                  const importedName = specifier.imported.name
+
+                  for (const variable of sourceCode.getDeclaredVariables(specifier)) {
+                    for (const ref of variable.references) {
+                      if (ref.identifier.range[0] === specifier.local.range[0]) continue
+                      fixes.push(
+                        fixer.replaceTextRange(
+                          ref.identifier.range,
+                          localName !== importedName
+                            ? `${baseName}.${importedName}`
+                            : `${baseName}.${localName}`,
+                        ),
+                      )
+                    }
+                  }
+                }
+
+                return fixes
               },
             })
           },
@@ -182,6 +205,214 @@ export default {
       },
     },
 
+    "no-destructured-params": {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description: "Disallow destructuring objects in function parameters",
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+          noDestructuredParam:
+            "Avoid destructuring objects in function parameters. Use a single parameter and access properties on it instead.",
+        },
+      },
+      create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode()
+
+        function findUnusedName(scope, base) {
+          const names = new Set()
+          let current = scope
+          while (current) {
+            for (const v of current.variables) names.add(v.name)
+            current = current.upper
+          }
+          if (!names.has(base)) return base
+          for (let i = 2; ; i++) {
+            const candidate = base + i
+            if (!names.has(candidate)) return candidate
+          }
+        }
+
+        function isDefinition(node) {
+          if (node.type === "FunctionDeclaration") return true
+          const ancestors = sourceCode.getAncestors(node)
+          const parent = ancestors[ancestors.length - 1]
+          if (!parent) return false
+          if (parent.type === "MethodDefinition" || (parent.type === "Property" && parent.method))
+            return true
+          if (parent.type === "VariableDeclarator" && parent.init === node) return true
+          return false
+        }
+
+        function checkParams(node) {
+          for (const param of node.params) {
+            const pattern = param.type === "AssignmentPattern" ? param.left : param
+            if (pattern.type !== "ObjectPattern") continue
+
+            const baseName = isDefinition(node) ? "options" : "v"
+            const outerScope = sourceCode.getScope(node).upper || sourceCode.getScope(node)
+            const name = findUnusedName(outerScope, baseName)
+
+            const hasPropertyDefaults = pattern.properties.some(
+              (prop) => prop.type !== "RestElement" && prop.value.type === "AssignmentPattern",
+            )
+
+            context.report({
+              node: pattern,
+              messageId: "noDestructuredParam",
+              fix: hasPropertyDefaults
+                ? undefined
+                : (fixer) => {
+                    const fixes = []
+
+                    const typeAnnotation = pattern.typeAnnotation
+                      ? sourceCode.getText(pattern.typeAnnotation)
+                      : ""
+                    const hasDefault = param.type === "AssignmentPattern"
+                    const defaultValue = hasDefault ? " = " + sourceCode.getText(param.right) : ""
+
+                    fixes.push(
+                      fixer.replaceTextRange(param.range, name + typeAnnotation + defaultValue),
+                    )
+
+                    const fnScope = sourceCode.getScope(node)
+                    const localToKey = new Map()
+                    for (const prop of pattern.properties) {
+                      if (prop.type === "RestElement") continue
+                      const keyName =
+                        prop.key.type === "Identifier"
+                          ? prop.key.name
+                          : sourceCode.getText(prop.key)
+                      const localNode =
+                        prop.value.type === "AssignmentPattern" ? prop.value.left : prop.value
+                      if (localNode.type === "Identifier") {
+                        localToKey.set(localNode.name, keyName)
+                      }
+                    }
+
+                    for (const variable of fnScope.variables) {
+                      const keyName = localToKey.get(variable.name)
+                      if (keyName === undefined) continue
+
+                      for (const ref of variable.references) {
+                        if (
+                          ref.identifier.range[0] >= pattern.range[0] &&
+                          ref.identifier.range[1] <= pattern.range[1]
+                        )
+                          continue
+
+                        const ancestors = sourceCode.getAncestors(ref.identifier)
+                        const parent = ancestors[ancestors.length - 1]
+                        if (
+                          parent &&
+                          parent.type === "Property" &&
+                          parent.shorthand &&
+                          parent.value === ref.identifier
+                        ) {
+                          fixes.push(
+                            fixer.replaceTextRange(
+                              parent.range,
+                              keyName + ": " + name + "." + keyName,
+                            ),
+                          )
+                        } else {
+                          fixes.push(
+                            fixer.replaceTextRange(ref.identifier.range, name + "." + keyName),
+                          )
+                        }
+                      }
+                    }
+
+                    return fixes
+                  },
+            })
+          }
+        }
+
+        return {
+          FunctionDeclaration: checkParams,
+          FunctionExpression: checkParams,
+          ArrowFunctionExpression: checkParams,
+        }
+      },
+    },
+
+    "namespace-import-mismatch": {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description:
+            "Warn when a namespace import alias doesn't match the basename of the module path",
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+          mismatch:
+            'Namespace import alias "{{alias}}" does not match module basename "{{baseName}}"',
+        },
+      },
+      create(context) {
+        const importNames = new Set()
+
+        return {
+          ImportDeclaration(node) {
+            for (const spec of node.specifiers) {
+              importNames.add(spec.local.name)
+            }
+
+            const source = node.source.value
+            if (typeof source !== "string") return
+
+            if (
+              node.specifiers.length !== 1 ||
+              node.specifiers[0].type !== "ImportNamespaceSpecifier"
+            ) {
+              return
+            }
+
+            if (!isLocalImport(source)) return
+
+            const baseName = getBaseName(source)
+            if (!baseName) return
+            if (!isCapitalized(baseName)) return
+
+            const alias = node.specifiers[0].local.name
+            if (alias === baseName) return
+
+            const hasCollision = importNames.has(baseName) && alias !== baseName
+            const sourceCode = context.sourceCode || context.getSourceCode()
+
+            context.report({
+              node,
+              messageId: "mismatch",
+              data: { alias, baseName },
+              fix: hasCollision
+                ? undefined
+                : (fixer) => {
+                    const fixes = [
+                      fixer.replaceText(
+                        node,
+                        `import ${node.importKind === "type" ? "type " : ""}* as ${baseName} from "${source}"`,
+                      ),
+                    ]
+
+                    for (const variable of sourceCode.getDeclaredVariables(node.specifiers[0])) {
+                      for (const ref of variable.references) {
+                        if (ref.identifier.range[0] === node.specifiers[0].local.range[0]) continue
+                        fixes.push(fixer.replaceTextRange(ref.identifier.range, baseName))
+                      }
+                    }
+
+                    return fixes
+                  },
+            })
+          },
+        }
+      },
+    },
+
     "test-assertion-newline": {
       meta: {
         type: "layout",
@@ -382,6 +613,10 @@ function getBaseName(source) {
   return last
 }
 
+function isLocalImport(source) {
+  return source.startsWith(".") || source.startsWith("/")
+}
+
 function isCapitalized(name) {
   return name.length > 0 && name[0] >= "A" && name[0] <= "Z"
 }