liminal 0.17.10 → 0.17.11

package/actor/ActorRegistry.ts

@@ -0,0 +1,361 @@
+import {
+  Layer,
+  Effect,
+  Scope,
+  Schema as S,
+  Context,
+  ManagedRuntime,
+  ConfigProvider,
+  Duration,
+  flow,
+  String,
+  Array,
+  Encoding,
+  Option,
+} from "effect"
+import { HttpServerResponse, HttpClient, FetchHttpClient } from "effect/unstable/http"
+
+import type { ActorTransport } from "./ActorTransport.ts"
+import type * as Method from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
+
+import * as Binding from "../Binding.ts"
+import * as DoState from "../DoState.ts"
+import * as NativeRequest from "../NativeRequest.ts"
+import { SecWebSocketProtocol, close } from "../socket_util.ts"
+import { boundLayer } from "../util/boundLayer.ts"
+import * as Diagnostic from "../util/Diagnostic.ts"
+import { logCause } from "../util/logCause.ts"
+import * as Mutex from "../util/Mutex.ts"
+import { type TopFromString, encodeJsonString, decodeJsonString } from "../util/schema.ts"
+import * as Actor from "./Actor.ts"
+import * as ClientDirectory from "./ClientDirectory.ts"
+
+const { debug, span } = Diagnostic.module("cloudflare.ActorRegistry")
+
+export interface ActorRegistryDefinition<
+  ActorSelf,
+  ActorId extends string,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  ClientSelf,
+  ClientId extends string,
+  D extends ProtocolDefinition,
+  PreludeROut,
+  PreludeE,
+  RunROut,
+  RunE,
+> {
+  readonly ""?: this["actor"]["definition"]["client"]["protocol"]
+
+  readonly actor: Actor.Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>
+
+  readonly prelude: Layer.Layer<
+    | PreludeROut
+    | NonNullable<this[""]>["F"]["Payload"]["DecodingServices"]
+    | NonNullable<this[""]>["F"]["Success"]["EncodingServices"]
+    | NonNullable<this[""]>["F"]["Failure"]["EncodingServices"]
+    | NonNullable<this[""]>["Event"]["EncodingServices"]
+    | S.Struct<AttachmentFields>["DecodingServices"]
+    | S.Struct<AttachmentFields>["EncodingServices"]
+    | Name["EncodingServices"]
+    | Name["DecodingServices"],
+    PreludeE
+  >
+
+  readonly runLayer: Layer.Layer<RunROut, RunE, ActorSelf | PreludeROut>
+
+  readonly handlers: Method.Handlers<
+    D["methods"],
+    ActorSelf | RunROut | HttpClient.HttpClient | PreludeROut | Scope.Scope
+  >
+
+  readonly onConnect: Effect.Effect<
+    void,
+    never,
+    ActorSelf | RunROut | HttpClient.HttpClient | PreludeROut | Scope.Scope
+  >
+
+  readonly hibernation?: Duration.Input | undefined
+}
+
+export interface ActorRegistry<
+  RegistrySelf,
+  RegistryId extends string,
+  ActorSelf,
+  ActorId extends string,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  ClientSelf,
+  ClientId extends string,
+  D extends ProtocolDefinition,
+  PreludeROut,
+  PreludeE,
+  RunROut,
+  RunE,
+> extends Context.Service<RegistrySelf, DurableObjectNamespace> {
+  new (state: globalThis.DurableObjectState<{}>): Context.ServiceClass.Shape<RegistryId, DurableObjectNamespace>
+
+  readonly definition: ActorRegistryDefinition<
+    ActorSelf,
+    ActorId,
+    Name,
+    AttachmentFields,
+    ClientSelf,
+    ClientId,
+    D,
+    PreludeROut,
+    PreludeE,
+    RunROut,
+    RunE
+  >
+
+  readonly upgrade: (
+    name: Name["Type"],
+    attachments: S.Struct<AttachmentFields>["Type"],
+  ) => Effect.Effect<HttpServerResponse.HttpServerResponse, S.SchemaError, RegistrySelf | NativeRequest.NativeRequest>
+
+  readonly layer: (binding: string) => Layer.Layer<RegistrySelf, S.SchemaError, never>
+}
+
+export const Service =
+  <RegistrySelf>() =>
+  <
+    RegistryId extends string,
+    ActorSelf,
+    ActorId extends string,
+    Name extends TopFromString,
+    AttachmentFields extends S.Struct.Fields,
+    ClientSelf,
+    ClientId extends string,
+    D extends ProtocolDefinition,
+    PreludeROut,
+    PreludeE,
+    RunROut,
+    RunE,
+  >(
+    id: RegistryId,
+    definition: ActorRegistryDefinition<
+      ActorSelf,
+      ActorId,
+      Name,
+      AttachmentFields,
+      ClientSelf,
+      ClientId,
+      D,
+      PreludeROut,
+      PreludeE,
+      RunROut,
+      RunE
+    >,
+  ): ActorRegistry<
+    RegistrySelf,
+    RegistryId,
+    ActorSelf,
+    ActorId,
+    Name,
+    AttachmentFields,
+    ClientSelf,
+    ClientId,
+    D,
+    PreludeROut,
+    PreludeE,
+    RunROut,
+    RunE
+  > => {
+    const { hibernation, actor, prelude, runLayer, handlers, onConnect } = definition
+    const {
+      definition: {
+        name: Name,
+        client: { key: clientId, protocol: P },
+        attachments: AttachmentFields,
+      },
+    } = actor
+
+    const encodeName = S.encodeEffect(Name)
+    const decodeName = S.decodeUnknownEffect(Name)
+
+    const Attachments = S.Struct(AttachmentFields)
+    const encodeAttachments = S.encodeEffect(S.toCodecJson(Attachments))
+    const decodeAttachments = S.decodeUnknownEffect(S.toCodecJson(Attachments))
+    const encodeAttachmentsString = encodeJsonString(Attachments)
+    const decodeAttachmentsString = decodeJsonString(Attachments)
+
+    const encodeAuditionSuccess = encodeJsonString(P.Audition.Success)
+    const encodeAuditionFailure = encodeJsonString(P.Audition.Failure)
+    const decodeClientM = decodeJsonString(P.Client)
+    const encodeFSuccess = encodeJsonString(P.F.Success)
+    const encodeFFailure = encodeJsonString(P.F.Failure)
+
+    const encodeEvent = encodeJsonString(P.Event)
+
+    const transport: ActorTransport<WebSocket, AttachmentFields, D> = {
+      send: (socket, event) => encodeEvent(event).pipe(Effect.andThen((v) => Effect.sync(() => socket.send(v)))),
+      close: (socket) => Effect.sync(() => socket.close(1000)),
+      snapshot: (socket, attachments) =>
+        encodeAttachments(attachments).pipe(Effect.andThen((v) => Effect.sync(() => socket.serializeAttachment(v)))),
+    }
+
+    const tag = class tag extends Context.Service<RegistrySelf, DurableObjectNamespace>()(id) {
+      readonly runtime
+      readonly directory = ClientDirectory.make(actor, transport)
+
+      constructor(...args: [never]) {
+        super(...args)
+        const [state, env] = args as never as [state: globalThis.DurableObjectState<{}>, env: unknown]
+
+        if (hibernation) {
+          Option.andThen(
+            Duration.fromInput(hibernation),
+            flow(Duration.toMillis, state.setHibernatableWebSocketEventTimeout),
+          )
+        }
+
+        const baseLayer = Layer.mergeAll(
+          prelude.pipe(Layer.provideMerge(ConfigProvider.layer(ConfigProvider.fromUnknown(env)))),
+          FetchHttpClient.layer,
+          Layer.succeed(DoState.DoState, state),
+          Mutex.layer,
+        )
+
+        this.runtime = Effect.gen({ self: this }, function* () {
+          this.#name = yield* Effect.tryPromise(() => state.storage.get("__liminal_name")).pipe(
+            Effect.flatMap((v) => (typeof v === "string" ? decodeName(v) : Effect.succeed(undefined))),
+          )
+          for (const socket of state.getWebSockets()) {
+            const attachments = yield* decodeAttachments(socket.deserializeAttachment())
+            yield* this.directory.register(socket, attachments)
+          }
+        }).pipe(
+          Effect.tapCause(logCause),
+          span("make_runtime"),
+          Layer.effectDiscard,
+          Layer.provideMerge(baseLayer),
+          boundLayer("actor"),
+          ManagedRuntime.make,
+        )
+      }
+
+      #name?: Name["Type"] | undefined
+      fetch(request: Request): Promise<Response> {
+        return Effect.gen({ self: this }, function* () {
+          const url = new URL(request.url)
+          const name = yield* decodeName(url.searchParams.get("__liminal_name"))
+          const attachments = yield* decodeAttachmentsString(url.searchParams.get("__liminal_attachments"))
+          if (!this.#name) {
+            this.#name = name
+            const state = yield* DoState.DoState
+            const encoded = yield* S.encodeEffect(Name)(name)
+            yield* Effect.promise(() => state.storage.put("__liminal_name", encoded))
+          }
+          const { 0: webSocket, 1: server } = new WebSocketPair()
+          const state = yield* DoState.DoState
+          state.acceptWebSocket(server)
+          server.send(yield* encodeAuditionSuccess({ _tag: "Audition.Success" }))
+          const currentClient = yield* this.directory.register(server, attachments)
+          const ActorLive = Layer.succeed(actor, {
+            name,
+            clients: this.directory.handles,
+            currentClient,
+          })
+          yield* onConnect.pipe(
+            Effect.scoped,
+            span("onConnect"),
+            Effect.provide([ActorLive, runLayer.pipe(Layer.provideMerge(ActorLive))]),
+          )
+          return new Response(null, {
+            status: 101,
+            webSocket,
+            headers: { [SecWebSocketProtocol]: "liminal" },
+          })
+        }).pipe(Effect.scoped, Effect.tapCause(logCause), span("fetch"), this.runtime.runPromise)
+      }
+
+      webSocketMessage(socket: WebSocket, raw: string | ArrayBuffer) {
+        Effect.gen({ self: this }, function* () {
+          const currentClient = yield* this.directory.get(socket)
+          const name = yield* Effect.fromNullishOr(this.#name)
+          const layer = Layer.succeed(actor, {
+            name,
+            clients: this.directory.handles,
+            currentClient,
+          })
+          const message = yield* decodeClientM(raw instanceof ArrayBuffer ? new TextDecoder().decode(raw) : raw)
+          yield* debug("MessageReceived", { message })
+          if (message._tag === "Audition.Payload") {
+            return yield* Effect.die(undefined)
+          }
+          if (message._tag === "Disconnect") {
+            return yield* currentClient.disconnect
+          }
+          const { id, payload } = message
+          const { _tag, value } = payload as never
+          yield* handlers[_tag]!(value).pipe(
+            Effect.provide(runLayer.pipe(Layer.provideMerge(layer))),
+            Effect.matchEffect({
+              onSuccess: (value) =>
+                encodeFSuccess({
+                  _tag: "F.Success",
+                  id,
+                  success: { _tag, value } as never,
+                }),
+              onFailure: (value) =>
+                encodeFFailure({
+                  _tag: "F.Failure",
+                  id,
+                  failure: { _tag, value } as never,
+                }),
+            }),
+            span("handler", { attributes: { _tag } }),
+            Effect.andThen((v) => Effect.sync(() => socket.send(v))),
+            Effect.scoped,
+          )
+        }).pipe(Effect.scoped, Mutex.task, Effect.tapCause(logCause), span("webSocketMessage"), this.runtime.runFork)
+      }
+
+      webSocketClose(socket: WebSocket, _code: number, _reason: string, _wasClean: boolean) {
+        this.directory
+          .unregister(socket)
+          .pipe(Effect.tap(debug("SocketClosed")), Effect.tapCause(logCause), this.runtime.runFork)
+      }
+
+      webSocketError(socket: WebSocket, cause: unknown) {
+        Effect.gen({ self: this }, function* () {
+          yield* debug("SocketErrored", { cause })
+          yield* this.directory.unregister(socket)
+        }).pipe(Effect.tapCause(logCause), span("SocketErrored", { attributes: { cause } }), this.runtime.runFork)
+      }
+    }
+
+    const upgrade = Effect.fnUntraced(function* (name: Name["Type"], attachments: (typeof Attachments)["Type"]) {
+      yield* debug("UpgradeInitiated", { attachments })
+      const namespace = yield* tag
+      const nameEncoded = yield* encodeName(name)
+      const stub = namespace.getByName(nameEncoded)
+      const request = yield* NativeRequest.NativeRequest
+      const protocols = yield* Effect.fromNullishOr(request.headers.get(SecWebSocketProtocol)).pipe(
+        Effect.map(flow(String.split(","), Array.map(String.trim))),
+      )
+      const liminalTokenI = yield* Array.findFirstIndex(protocols, (v) => v === "liminal")
+      const requestClientId = yield* Effect.fromNullishOr(protocols[liminalTokenI + 1]).pipe(
+        Effect.flatMap((v) => Encoding.decodeBase64UrlString(v).asEffect()),
+      )
+      if (requestClientId !== clientId) {
+        return close(
+          yield* encodeAuditionFailure({
+            _tag: "Audition.Failure",
+            expected: clientId,
+            actual: requestClientId,
+          }),
+        )
+      }
+      const url = new URL(request.url)
+      url.searchParams.set("__liminal_name", nameEncoded)
+      url.searchParams.set("__liminal_attachments", yield* encodeAttachmentsString(attachments))
+      return yield* Effect.promise(() => stub.fetch(new Request(url, request))).pipe(Effect.map(HttpServerResponse.raw))
+    }, span("upgrade"))
+
+    const layer = Binding.layer(tag, ["getByName"])
+
+    return Object.assign(tag, { definition, upgrade, layer }) as never
+  }

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

@@ -3,7 +3,7 @@ import { Schema as S, Pipeable, Stream, Effect, Function } from "effect"
 import type { F } from "./F.ts"
 import type { ProtocolDefinition } from "./Protocol.ts"
 
-import * as Diagnostic from "./_util/Diagnostic.ts"
+import * as Diagnostic from "../util/Diagnostic.ts"
 import * as Client from "./Client.ts"
 import { type ClientError, AuditionError } from "./errors.ts"
 

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

@@ -25,8 +25,8 @@ import {
 import { Socket } from "effect/unstable/socket"
 import { Worker } from "effect/unstable/workers"
 
-import * as Diagnostic from "./_util/Diagnostic.ts"
-import { decodeJsonString, encodeJsonString } from "./_util/schema.ts"
+import * as Diagnostic from "../util/Diagnostic.ts"
+import { decodeJsonString, encodeJsonString } from "../util/schema.ts"
 import { type ClientError, AuditionError, ConnectionError, type FError, UnresolvedError } from "./errors.ts"
 import { type F } from "./F.ts"
 import { Protocol, type ProtocolDefinition } from "./Protocol.ts"

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

@@ -1,12 +1,12 @@
 import { Schema as S, Effect, Cause, Ref } from "effect"
 
-import type { TopFromString } from "./_util/schema.ts"
+import type { TopFromString } from "../util/schema.ts"
 import type { Actor } from "./Actor.ts"
 import type { ActorTransport } from "./ActorTransport.ts"
 import type { ProtocolDefinition, Disconnect, Protocol } from "./Protocol.ts"
 
-import * as Diagnostic from "./_util/Diagnostic.ts"
-import { phantom } from "./_util/phantom.ts"
+import * as Diagnostic from "../util/Diagnostic.ts"
+import { phantom } from "../util/phantom.ts"
 import * as ClientHandle from "./ClientHandle.ts"
 
 const { span } = Diagnostic.module("ClientDirectory")

package/actor/index.ts

@@ -0,0 +1,11 @@
+export * as Actor from "./Actor.ts"
+export * as ActorRegistry from "./ActorRegistry.ts"
+export * as Audition from "./Audition.ts"
+export * as Client from "./Client.ts"
+export * as ClientDirectory from "./ClientDirectory.ts"
+export * as ClientHandle from "./ClientHandle.ts"
+export * as Method from "./Method.ts"
+export * as Protocol from "./Protocol.ts"
+export * from "./ActorTransport.ts"
+export * from "./F.ts"
+export * from "./errors.ts"

package/asset_forwarding.ts

@@ -0,0 +1,13 @@
+import { Effect, Layer } from "effect"
+import { HttpServerResponse } from "effect/unstable/http"
+
+import * as Assets from "./Assets.ts"
+import * as Worker from "./Worker.ts"
+
+export default Worker.make({
+  handler: Assets.forward.pipe(
+    Effect.provide(Assets.layer("ASSETS")),
+    Effect.catch(() => Effect.succeed(HttpServerResponse.empty({ status: 500 }))),
+  ),
+  prelude: Layer.empty,
+})

package/commands/sync-env.ts

@@ -0,0 +1,30 @@
+import { Config, Effect, Path, Redacted } from "effect"
+import { Argument, Command } from "effect/unstable/cli"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+
+export const syncEnv = Command.make("sync-env", {
+  worker: Argument.directory("worker", { mustExist: true }),
+  configFile: Argument.file("config-file", { mustExist: true }),
+  configExport: Argument.string("config-export").pipe(Argument.withDefault("config")),
+}).pipe(
+  Command.withHandler(
+    Effect.fn(function* ({ worker, configFile, configExport }) {
+      const path = yield* Path.Path
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+      const url = yield* path.toFileUrl(path.resolve(configFile))
+      const module = yield* Effect.tryPromise(() => import(url.href))
+      const config = module[configExport] as Config.Config<Record<string, Redacted.Redacted<string>>>
+      const env = yield* config
+      for (const [name, value] of Object.entries(env)) {
+        yield* spawner.spawn(
+          ChildProcess.make({
+            stdout: "inherit",
+            stderr: "inherit",
+            cwd: worker,
+          })`pnpm wrangler secret put ${name} ${Redacted.value(value)}`,
+        )
+        yield* Effect.log(`Synced ${name} to ${worker}.`)
+      }
+    }),
+  ),
+)

package/dist/Ai.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "effect";
+declare const Ai_base: Context.ServiceClass<Ai, "liminal/Ai", globalThis.Ai<AiModels>>;
+export declare class Ai extends Ai_base {
+}
+export declare const layer: (binding: string) => import("effect/Layer").Layer<Ai, import("effect/Schema").SchemaError, never>;
+export {};

package/dist/Ai.js

@@ -0,0 +1,6 @@
+import { Context } from "effect";
+import * as Binding from "./Binding.js";
+export class Ai extends Context.Service()("liminal/Ai") {
+}
+export const layer = Binding.layer(Ai, ["run"]);
+//# sourceMappingURL=Ai.js.map

package/dist/Ai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ai.js","sourceRoot":"","sources":["../Ai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAEhC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,MAAM,OAAO,EAAG,SAAQ,OAAO,CAAC,OAAO,EAAqB,CAAC,YAAY,CAAC;CAAG;AAE7E,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA"}

package/dist/Assets.d.ts

@@ -0,0 +1,11 @@
+import { Effect, Context } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import { NativeRequest } from "./NativeRequest.ts";
+declare const Assets_base: Context.ServiceClass<Assets, "liminal/Assets", {
+    readonly fetch: typeof fetch;
+}>;
+export declare class Assets extends Assets_base {
+}
+export declare const layer: (binding: string) => import("effect/Layer").Layer<Assets, import("effect/Schema").SchemaError, never>;
+export declare const forward: Effect.Effect<HttpServerResponse.HttpServerResponse, never, Assets | NativeRequest>;
+export {};

package/dist/Assets.js

@@ -0,0 +1,14 @@
+import { Effect, Context } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import * as Binding from "./Binding.js";
+import { NativeRequest } from "./NativeRequest.js";
+export class Assets extends Context.Service()("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);
+});
+//# sourceMappingURL=Assets.js.map

package/dist/Assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Assets.js","sourceRoot":"","sources":["../Assets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAElD,MAAM,OAAO,MAAO,SAAQ,OAAO,CAAC,OAAO,EAKxC,CAAC,gBAAgB,CAAC;CAAG;AAExB,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,CAAC,CAAA;AAErD,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,QAAQ,CAAC;IACzD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;IAC5B,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,aAAa,CAAA;IACpC,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;IACnE,OAAO,kBAAkB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;AAC7C,CAAC,CAAC,CAAA"}

package/dist/Binding.d.ts

@@ -0,0 +1,2 @@
+import { Context, Layer, Schema as S } from "effect";
+export declare 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) => Layer.Layer<ROut | Self, E | S.SchemaError, RIn>;

package/dist/Binding.js

@@ -0,0 +1,19 @@
+import { env } from "cloudflare:workers";
+import { Context, Layer, Effect, Schema as S, SchemaIssue } from "effect";
+export const layer = (tag, keys, derive) => (binding) => Effect.gen(function* () {
+    const resolved = env[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);
+//# sourceMappingURL=Binding.js.map

package/dist/Binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Binding.js","sourceRoot":"","sources":["../Binding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAEzE,MAAM,CAAC,MAAM,KAAK,GAChB,CACE,GAAkD,EAClD,IAA2B,EAC3B,MAAmE,EACnE,EAAE,CACJ,CAAC,OAAe,EAAE,EAAE,CAClB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,QAAQ,GAAI,GAAa,CAAC,OAAO,CAAC,CAAA;IACxC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,CAAC,CAAC,WAAW,CACf,IAAI,WAAW,CAAC,OAAO,CACrB,CAAC,OAAO,CAAC,EACT,IAAI,WAAW,CAAC,UAAU,CAAC;YACzB,iBAAiB,EAAE,oBAAoB,OAAO,UAAU;SACzD,CAAC,CACH,CACF,CACF,CAAA;IACH,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,CAAC,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC;YACvB,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,CAAC,CAAC,WAAW,CACf,IAAI,WAAW,CAAC,OAAO,CACrB,CAAC,GAAG,CAAC,EACL,IAAI,WAAW,CAAC,UAAU,CAAC;gBACzB,iBAAiB,EAAE,kBAAkB,GAAG,mBAAmB,OAAO,IAAI;aACvE,CAAC,CACH,CACF,CACF,CAAA;QACH,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAA;AACxF,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA"}

package/dist/D1.d.ts

@@ -0,0 +1,7 @@
+import { D1Client } from "@effect/sql-d1";
+import { Context } from "effect";
+declare const D1_base: Context.ServiceClass<D1, "liminal/D1", D1Database>;
+export declare class D1 extends D1_base {
+}
+export declare const layer: (binding: string) => import("effect/Layer").Layer<D1 | D1Client.D1Client | import("effect/unstable/sql/SqlClient").SqlClient, import("effect/Config").ConfigError | import("effect/Schema").SchemaError, never>;
+export {};

package/dist/D1.js

@@ -0,0 +1,7 @@
+import { D1Client } from "@effect/sql-d1";
+import { Context } from "effect";
+import * as Binding from "./Binding.js";
+export class D1 extends Context.Service()("liminal/D1") {
+}
+export const layer = Binding.layer(D1, ["exec"], (db) => D1Client.layer({ db }));
+//# sourceMappingURL=D1.js.map

package/dist/D1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1.js","sourceRoot":"","sources":["../D1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAEhC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,MAAM,OAAO,EAAG,SAAQ,OAAO,CAAC,OAAO,EAAkB,CAAC,YAAY,CAAC;CAAG;AAE1E,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA"}

package/dist/DoState.d.ts

@@ -0,0 +1,5 @@
+import { Context } from "effect";
+declare const DoState_base: Context.ServiceClass<DoState, "liminal/DoState", DurableObjectState<{}>>;
+export declare class DoState extends DoState_base {
+}
+export {};

package/dist/DoState.js

@@ -0,0 +1,4 @@
+import { Context } from "effect";
+export class DoState extends Context.Service()("liminal/DoState") {
+}
+//# sourceMappingURL=DoState.js.map

package/dist/DoState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DoState.js","sourceRoot":"","sources":["../DoState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAEhC,MAAM,OAAO,OAAQ,SAAQ,OAAO,CAAC,OAAO,EAA8C,CAAC,iBAAiB,CAAC;CAAG"}

package/dist/Hyperdrive.d.ts

@@ -0,0 +1,7 @@
+import { Effect, Redacted, Context } from "effect";
+declare const Hyperdrive_base: Context.ServiceClass<Hyperdrive, "liminal/Hyperdrive", globalThis.Hyperdrive>;
+export declare class Hyperdrive extends Hyperdrive_base {
+}
+export declare const layer: (binding: string) => import("effect/Layer").Layer<Hyperdrive, import("effect/Schema").SchemaError, never>;
+export declare const connectionString: Effect.Effect<Redacted.Redacted<string>, never, Hyperdrive>;
+export {};

package/dist/Hyperdrive.js

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

package/dist/Hyperdrive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hyperdrive.js","sourceRoot":"","sources":["../Hyperdrive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAElD,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,MAAM,OAAO,UAAW,SAAQ,OAAO,CAAC,OAAO,EAAqC,CAAC,oBAAoB,CAAC;CAAG;AAE7G,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAA;AAEpE,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC,IAAI,CACxD,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CACtE,CAAA"}

package/dist/Images.d.ts

@@ -0,0 +1,39 @@
+import { Data, Context, Pipeable, Effect } from "effect";
+declare const Images_base: Context.ServiceClass<Images, "liminal/ImageTransformer", ImagesBinding>;
+export declare class Images extends Images_base {
+}
+export declare const layer: (binding: string) => import("effect/Layer").Layer<Images, import("effect/Schema").SchemaError, never>;
+declare const TypeId: "~liminal/Images/Transformation";
+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 declare const empty: Steps;
+export declare const transform: {
+    (transform: ImageTransform): (steps: Steps) => Steps;
+    (steps: Steps, transform: ImageTransform): Steps;
+};
+export declare const draw: {
+    (draw: DrawOptions): (steps: Steps) => Steps;
+    (steps: Steps, draw: DrawOptions): Steps;
+};
+export interface ProcessConfig {
+    readonly stream: ReadableStream<Uint8Array>;
+    readonly inputOptions?: ImageInputOptions | undefined;
+    readonly outputOptions: ImageOutputOptions;
+}
+export declare const process: {
+    (config: ProcessConfig): (steps: Steps) => Effect.Effect<ImageTransformationResult, never, Images>;
+    (steps: Steps, config: ProcessConfig): Effect.Effect<ImageTransformationResult, never, Images>;
+};
+export {};