liminal 0.17.9 → 0.17.11

package/Ai.ts

@@ -0,0 +1,7 @@
+import { Context } from "effect"
+
+import * as Binding from "./Binding.ts"
+
+export class Ai extends Context.Service<Ai, globalThis.Ai>()("liminal/Ai") {}
+
+export const layer = Binding.layer(Ai, ["run"])

package/Assets.ts

@@ -0,0 +1,21 @@
+import { Effect, Context } from "effect"
+import { HttpServerResponse } from "effect/unstable/http"
+
+import * as Binding from "./Binding.ts"
+import { NativeRequest } from "./NativeRequest.ts"
+
+export class Assets extends Context.Service<
+  Assets,
+  {
+    readonly fetch: typeof fetch
+  }
+>()("liminal/Assets") {}
+
+export const layer = Binding.layer(Assets, ["fetch"])
+
+export const forward = Effect.gen({ self: this }, function* () {
+  const assets = yield* Assets
+  const request = yield* NativeRequest
+  const response = yield* Effect.promise(() => assets.fetch(request))
+  return HttpServerResponse.fromWeb(response)
+})

package/Binding.ts

@@ -0,0 +1,40 @@
+import { env } from "cloudflare:workers"
+import { Context, Layer, Effect, Schema as S, SchemaIssue } from "effect"
+
+export const layer =
+  <Self, Identifier extends string, Shape, ROut = never, E = never, RIn = never>(
+    tag: Context.ServiceClass<Self, Identifier, Shape>,
+    keys: ReadonlyArray<string>,
+    derive?: (resource: Shape) => Layer.Layer<ROut, E, RIn> | undefined,
+  ) =>
+  (binding: string) =>
+    Effect.gen(function* () {
+      const resolved = (env as never)[binding]
+      if (!resolved) {
+        return yield* Effect.fail(
+          new S.SchemaError(
+            new SchemaIssue.Pointer(
+              [binding],
+              new SchemaIssue.MissingKey({
+                messageMissingKey: `Missing binding "${binding}" on env`,
+              }),
+            ),
+          ),
+        )
+      }
+      for (const key of keys) {
+        if (!(key in resolved)) {
+          return yield* Effect.fail(
+            new S.SchemaError(
+              new SchemaIssue.Pointer(
+                [key],
+                new SchemaIssue.MissingKey({
+                  messageMissingKey: `Expected key \`${key}\` on binding \`${binding}\``,
+                }),
+              ),
+            ),
+          )
+        }
+      }
+      return Layer.mergeAll(Layer.succeed(tag, resolved), derive?.(resolved) ?? Layer.empty)
+    }).pipe(Layer.unwrap)

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # liminal
 
+## 0.17.11
+
+### Patch Changes
+
+- 01eb088: Move everything cloudflare-related directly into liminal.
+
+## 0.17.10
+
+### Patch Changes
+
+- 9583d0e: Rework the module structure for bindings.
+
 ## 0.17.9
 
 ### Patch Changes
@@ -28,7 +40,8 @@
 
 ### Patch Changes
 
-- 7a05f2b: Improve built-in logging. Add AI resource. Resolve issue in which client listener suspense propagated suspense to streams and calls.
+- 7a05f2b: Improve built-in logging. Add AI resource. Resolve issue in which client listener suspense propagated
+  suspense to streams and calls.
 
 ## 0.17.4
 

package/D1.ts

@@ -0,0 +1,8 @@
+import { D1Client } from "@effect/sql-d1"
+import { Context } from "effect"
+
+import * as Binding from "./Binding.ts"
+
+export class D1 extends Context.Service<D1, D1Database>()("liminal/D1") {}
+
+export const layer = Binding.layer(D1, ["exec"], (db) => D1Client.layer({ db }))

package/DoState.ts

@@ -0,0 +1,3 @@
+import { Context } from "effect"
+
+export class DoState extends Context.Service<DoState, globalThis.DurableObjectState<{}>>()("liminal/DoState") {}

package/Hyperdrive.ts

@@ -0,0 +1,11 @@
+import { Effect, Redacted, Context } from "effect"
+
+import * as Binding from "./Binding.ts"
+
+export class Hyperdrive extends Context.Service<Hyperdrive, globalThis.Hyperdrive>()("liminal/Hyperdrive") {}
+
+export const layer = Binding.layer(Hyperdrive, ["connectionString"])
+
+export const connectionString = Hyperdrive.asEffect().pipe(
+  Effect.map(({ connectionString }) => Redacted.make(connectionString)),
+)

package/Images.ts

@@ -0,0 +1,101 @@
+import { Data, Context, Pipeable, Function, Effect } from "effect"
+
+import * as Binding from "./Binding.ts"
+
+export class Images extends Context.Service<Images, globalThis.ImagesBinding>()("liminal/ImageTransformer") {}
+
+export const layer = Binding.layer(Images, ["transform", "draw", "output"])
+
+const TypeId = "~liminal/Images/Transformation" as const
+
+export interface Steps extends Pipeable.Pipeable {
+  readonly [TypeId]: typeof TypeId
+  readonly steps: ReadonlyArray<Step>
+}
+
+export interface DrawOptions {
+  image: ReadableStream<Uint8Array> | ImageTransformer
+  options?: ImageDrawOptions | undefined
+}
+
+export type Step = Data.TaggedEnum<{
+  Transform: {
+    transform: ImageTransform
+  }
+  Draw: DrawOptions
+}>
+
+export const empty: Steps = {
+  [TypeId]: TypeId,
+  steps: [],
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments)
+  },
+}
+
+export const transform: {
+  (transform: ImageTransform): (steps: Steps) => Steps
+  (steps: Steps, transform: ImageTransform): Steps
+} = Function.dual(2, (steps: Steps, transform: ImageTransform) => ({
+  [TypeId]: TypeId,
+  steps: [
+    ...steps.steps,
+    {
+      _tag: "Transform",
+      transform,
+    },
+  ],
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments)
+  },
+}))
+
+export const draw: {
+  (draw: DrawOptions): (steps: Steps) => Steps
+  (steps: Steps, draw: DrawOptions): Steps
+} = Function.dual(2, (steps: Steps, draw: DrawOptions) => ({
+  [TypeId]: TypeId,
+  steps: [
+    ...steps.steps,
+    {
+      _tag: "Draw",
+      ...draw,
+    },
+  ],
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments)
+  },
+}))
+
+export interface ProcessConfig {
+  readonly stream: ReadableStream<Uint8Array>
+  readonly inputOptions?: ImageInputOptions | undefined
+  readonly outputOptions: ImageOutputOptions
+}
+
+export const process: {
+  (config: ProcessConfig): (steps: Steps) => Effect.Effect<ImageTransformationResult, never, Images>
+  (steps: Steps, config: ProcessConfig): Effect.Effect<ImageTransformationResult, never, Images>
+} = Function.dual(
+  2,
+  Effect.fnUntraced(function* ({ steps }: Steps, { stream, inputOptions, outputOptions }: ProcessConfig) {
+    const images = yield* Images
+    let transformer = images.input(stream, inputOptions)
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i]!
+      switch (step._tag) {
+        case "Draw": {
+          const { image, options } = step
+          transformer = transformer.draw(image, options)
+          break
+        }
+        case "Transform": {
+          const { transform } = step
+          transformer = transformer.transform(transform)
+          break
+        }
+      }
+    }
+    return yield* Effect.promise(() => transformer.output(outputOptions))
+  }),
+)

package/Kv.ts

@@ -0,0 +1,65 @@
+import { Effect, Schema as S, Option, Context, Layer } from "effect"
+
+import * as Binding from "./Binding.ts"
+
+export interface Kv<
+  Self,
+  Id extends string,
+  Key extends S.Top & { Encoded: string },
+  Value extends S.Top,
+> extends Context.Service<Self, KVNamespace> {
+  new (_: never): Context.ServiceClass<Self, Id, KVNamespace>
+
+  ""?: [Key, Value]
+
+  readonly put: (key: Key["Type"], value: Value["Type"]) => Effect.Effect<void, S.SchemaError, Self>
+
+  readonly get: (key: Key["Type"]) => Effect.Effect<Option.Option<Value["Type"]>, S.SchemaError, Self>
+
+  readonly remove: (key: Key["Type"]) => Effect.Effect<void, S.SchemaError, Self>
+
+  readonly layer: (binding: string) => Layer.Layer<Self, S.SchemaError>
+}
+
+export const Kv =
+  <Self>() =>
+  <Id extends string, Key extends S.Top & { Encoded: string }, Value extends S.Top>(
+    id: Id,
+    definition: {
+      readonly key: Key
+      readonly value: Value
+    },
+  ): Kv<Self, Id, Key, Value> => {
+    const tag = Context.Service<Self, KVNamespace>()(id)
+
+    const { key, value } = definition
+    const encodeKey = S.encodeEffect(key)
+    const encodeValue = S.encodeEffect(S.fromJsonString(S.toCodecJson(value)))
+    const decodeValue = S.decodeUnknownEffect(S.fromJsonString(S.toCodecJson(value)))
+
+    const put = Effect.fnUntraced(function* (key: Key["Type"], value: Value["Type"]) {
+      const kv = yield* tag
+      const keyEncoded = yield* encodeKey(key)
+      const valueEncoded = yield* encodeValue(value)
+      yield* Effect.promise(() => kv.put(keyEncoded, valueEncoded))
+    })
+
+    const get = Effect.fnUntraced(function* (key: Key["Type"]) {
+      const kv = yield* tag
+      const keyEncoded = yield* encodeKey(key)
+      const valueEncoded = yield* Effect.promise(() => kv.get(keyEncoded))
+      if (valueEncoded) {
+        return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some))
+      }
+      return Option.none()
+    })
+
+    const remove = Effect.fnUntraced(function* (key: Key["Type"]) {
+      const kv = yield* tag
+      const keyEncoded = yield* encodeKey(key)
+      yield* Effect.promise(() => kv.delete(keyEncoded))
+    })
+
+    const layer = Binding.layer(tag, ["put", "get", "delete"])
+    return Object.assign(tag, { definition, put, get, remove, layer }) as never
+  }

package/NativeRequest.ts

@@ -0,0 +1,3 @@
+import { Context } from "effect"
+
+export class NativeRequest extends Context.Service<NativeRequest, Request>()("liminal/NativeRequest") {}

package/R2.ts

@@ -0,0 +1,7 @@
+import { Context } from "effect"
+
+import * as Binding from "./Binding.ts"
+
+export class R2 extends Context.Service<R2, R2Bucket>()("liminal/R2") {}
+
+export const layer = Binding.layer(R2, ["put", "get"])

package/Worker.ts

@@ -0,0 +1,54 @@
+import { env } from "cloudflare:workers"
+import { Context, Layer, Scope, Effect, ManagedRuntime, ConfigProvider } from "effect"
+import {
+  HttpServerRequest,
+  HttpServerResponse,
+  HttpServerError,
+  HttpClient,
+  FetchHttpClient,
+} from "effect/unstable/http"
+
+import { NativeRequest } from "./NativeRequest.ts"
+import * as Diagnostic from "./util/Diagnostic.ts"
+import { logCause } from "./util/logCause.ts"
+
+const { span } = Diagnostic.module("cloudflare.Entry")
+
+export class ExecutionContext extends Context.Service<ExecutionContext, globalThis.ExecutionContext>()(
+  "liminal/ExecutionContext",
+) {}
+
+export interface WorkerConfig<ROut, E> {
+  readonly prelude: Layer.Layer<ROut, E>
+  readonly handler: Effect.Effect<
+    HttpServerResponse.HttpServerResponse,
+    HttpServerError.HttpServerError,
+    ExecutionContext | HttpServerRequest.HttpServerRequest | HttpClient.HttpClient | NativeRequest | ROut | Scope.Scope
+  >
+}
+
+export const make = <ROut, E>({ handler, prelude: layer }: WorkerConfig<ROut, E>) => {
+  const runtime = ManagedRuntime.make(
+    Layer.mergeAll(FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromUnknown(env))),
+  )
+  const fetch = (request: Request, _env: unknown, ctx: globalThis.ExecutionContext): Promise<Response> =>
+    handler.pipe(
+      Effect.map(HttpServerResponse.toWeb),
+      Effect.provide([
+        layer,
+        Layer.succeed(ExecutionContext, ctx),
+        Layer.succeed(NativeRequest, request),
+        Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)),
+      ]),
+      Effect.scoped,
+      Effect.tapCause(logCause),
+      span("fetch"),
+      // Solves crashes between HMRs.
+      // Without this, in-flight requests use an old memoMap; new requests use a new one.
+      // Aka. cross-contamination.
+      // TODO: investigate whether better-solved by https://github.com/dmmulroy/effect-cloudflare/blob/main/src/internal/wrangler.ts
+      Effect.provideService(Layer.CurrentMemoMap, runtime.memoMap),
+      runtime.runPromise,
+    )
+  return { fetch }
+}

package/WorkerLoader.ts

@@ -0,0 +1,29 @@
+import { absurd, Effect, Context } from "effect"
+import { HttpServerResponse } from "effect/unstable/http"
+
+import * as Binding from "./Binding.ts"
+
+export class WorkerLoader extends Context.Service<WorkerLoader, globalThis.WorkerLoader>()("liminal/WorkerLoader") {}
+
+export const layer = Binding.layer(WorkerLoader, ["load"])
+
+export const load = (id: string, code: string) =>
+  Effect.gen({ self: this }, function* () {
+    const loader = yield* WorkerLoader
+    return loader.get(id, () => ({
+      compatibilityDate: "2026-04-21",
+      mainModule: "main.js",
+      modules: { "main.js": code },
+      allowExperimental: true,
+      globalOutbound: null,
+    }))
+  })
+
+export const run = (id: string, request: Request) =>
+  Effect.gen({ self: this }, function* () {
+    const loader = yield* WorkerLoader
+    const worker = loader.get(id, () => absurd<never>(null!))
+    return yield* Effect.tryPromise(() => worker.getEntrypoint().fetch(request)).pipe(
+      Effect.map(HttpServerResponse.fromWeb),
+    )
+  })

package/{Actor.ts → actor/Actor.ts}

@@ -1,10 +1,10 @@
 import { Context, Schema as S, Effect } from "effect"
 
-import type { TopFromString } from "./_util/schema.ts"
+import type { TopFromString } from "../util/schema.ts"
 import type * as ActorClient from "./Client.ts"
 import type { ClientHandle, Sender } from "./ClientHandle.ts"
 
-import * as Diagnostic from "./_util/Diagnostic.ts"
+import * as Diagnostic from "../util/Diagnostic.ts"
 import * as Method from "./Method.ts"
 import { type ProtocolDefinition } from "./Protocol.ts"