liminal 0.17.1 → 0.17.2

package/errors.ts

@@ -1,14 +1,22 @@
 import { Schema as S } from "effect"
 
-export class AuditionError extends S.TaggedError<AuditionError>()("AuditionError", {
+import type { MethodDefinition } from "./Method.ts"
+
+export class AuditionError extends S.TaggedErrorClass<AuditionError>()("AuditionError", {
   value: S.Struct({
-    actual: S.String,
-    expected: S.String,
+    client: S.String,
+    routed: S.String,
   }).pipe(S.optional),
 }) {}
 
-export class ConnectionError extends S.TaggedError<ConnectionError>()("ConnectionError", {
+export class ConnectionError extends S.TaggedErrorClass<ConnectionError>()("ConnectionError", {
   cause: S.Unknown,
 }) {}
 
 export type ClientError = AuditionError | ConnectionError
+
+export class UnresolvedError extends S.TaggedErrorClass<UnresolvedError>()("UnresolvedError", {}) {}
+
+export type FError<MethodDefinitions extends Record<string, MethodDefinition.Any>> = [
+  MethodDefinitions[keyof MethodDefinitions]["failure"]["Type"] | ClientError | UnresolvedError,
+][0]

package/experimental/BranchLive.ts

@@ -1,5 +1,5 @@
-import { Chat } from "@effect/ai"
 import { Effect, Layer } from "effect"
+import { Chat } from "effect/unstable/ai"
 
 import { history } from "./L/history.ts"
 

package/experimental/L/append.ts

@@ -1,8 +1,8 @@
-import { Prompt, Chat } from "@effect/ai"
 import { Effect, flow, Ref } from "effect"
+import { Prompt, Chat } from "effect/unstable/ai"
 
 export const append = (message: Prompt.Message) =>
-  Chat.Chat.pipe(
+  Chat.Chat.asEffect().pipe(
     Effect.flatMap(
       flow(
         ({ history }) => history,

package/experimental/L/assistant.ts

@@ -1,5 +1,5 @@
-import { Prompt, LanguageModel } from "@effect/ai"
 import { Effect } from "effect"
+import { Prompt, LanguageModel } from "effect/unstable/ai"
 
 import { append } from "./append.ts"
 import { history } from "./history.ts"

package/experimental/L/assistantSchema.ts

@@ -1,11 +1,11 @@
-import { Prompt, LanguageModel } from "@effect/ai"
 import { Effect, Schema as S } from "effect"
+import { Prompt, LanguageModel } from "effect/unstable/ai"
 
 import { append } from "./append.ts"
 import { history } from "./history.ts"
 
-export const assistantSchema = Effect.fnUntraced(function* <A, I extends Record<string, unknown>, R>(
-  schema: S.Schema<A, I, R>,
+export const assistantSchema = Effect.fnUntraced(function* <A, I extends Record<string, unknown>>(
+  schema: S.Codec<A, I>,
 ) {
   const prompt = yield* history
   const { text, value } = yield* LanguageModel.generateObject({ prompt, schema })

package/experimental/L/assistantStream.ts

@@ -1,5 +1,5 @@
-import { LanguageModel } from "@effect/ai"
 import { Effect, Stream } from "effect"
+import { LanguageModel } from "effect/unstable/ai"
 
 import { history } from "./history.ts"
 

package/experimental/L/clear.ts

@@ -1,5 +1,5 @@
-import { Chat, Prompt } from "@effect/ai"
 import { Ref, Effect } from "effect"
+import { Chat, Prompt } from "effect/unstable/ai"
 
 export const clear = Effect.gen(function* () {
   const { history } = yield* Chat.Chat

package/experimental/L/history.ts

@@ -1,4 +1,4 @@
-import { Chat } from "@effect/ai"
 import { flow, Effect, Ref } from "effect"
+import { Chat } from "effect/unstable/ai"
 
-export const history = Chat.Chat.pipe(Effect.flatMap(flow(({ history }) => history, Ref.get)))
+export const history = Chat.Chat.asEffect().pipe(Effect.flatMap(flow(({ history }) => history, Ref.get)))

package/experimental/L/init.ts

@@ -1,4 +1,4 @@
-import { Chat } from "@effect/ai"
 import { Effect } from "effect"
+import { Chat } from "effect/unstable/ai"
 
 export const init = Effect.provideServiceEffect(Chat.Chat, Chat.empty)

package/experimental/L/matrix.ts

@@ -2,14 +2,14 @@ import { Effect, Function, Layer } from "effect"
 
 import { branch } from "./branch.ts"
 
-type LayerRecord = Record<string, Layer.Layer.Any>
+type LayerRecord = Record<string, Layer.Any>
 
 export type MatrixEffect<A, E, R, Layers extends LayerRecord> = Effect.Effect<
   {
     readonly [K in keyof Layers]: A
   },
-  E | Layer.Layer.Error<Layers[keyof Layers]>,
-  R | Layer.Layer.Context<Layers[keyof Layers]>
+  E | Layer.Error<Layers[keyof Layers]>,
+  R | Layer.Services<Layers[keyof Layers]>
 >
 
 export const matrix: {

package/experimental/L/system.ts

@@ -1,4 +1,4 @@
-import { Prompt } from "@effect/ai"
+import { Prompt } from "effect/unstable/ai"
 
 import { append } from "./append.ts"
 

package/experimental/L/user.ts

@@ -1,4 +1,4 @@
-import { Prompt } from "@effect/ai"
+import { Prompt } from "effect/unstable/ai"
 
 import { append } from "./append.ts"
 

package/experimental/Loader.ts

@@ -1,16 +1,16 @@
-import { Path, FileSystem } from "@effect/platform"
+import { Path, FileSystem } from "effect"
 import { Option, Layer, Effect, Data, Context } from "effect"
 
 export class LoaderError extends Data.TaggedError("LoaderError")<{
   readonly url: string
 }> {}
 
-export class Loader extends Context.Tag("liminal/Loader")<
+export class Loader extends Context.Service<
   Loader,
   {
     readonly load: (key: string) => Effect.Effect<Option.Option<string>, LoaderError>
   }
->() {}
+>()("liminal/Loader") {}
 
 export const layerFs = Layer.effect(
   Loader,

package/experimental/TaggedTemplateFunction.ts

@@ -6,11 +6,11 @@ export type TemplateStringsArrayLike = {
 
 type ExtractE<T> = [Extract<T, Effect.Effect<any, any, any>>] extends [never]
   ? never
-  : Effect.Effect.Error<Extract<T, Effect.Effect<any, any, any>>>
+  : Effect.Error<Extract<T, Effect.Effect<any, any, any>>>
 
 type ExtractR<T> = [Extract<T, Effect.Effect<any, any, any>>] extends [never]
   ? never
-  : Effect.Effect.Context<Extract<T, Effect.Effect<any, any, any>>>
+  : Effect.Services<Extract<T, Effect.Effect<any, any, any>>>
 
 export const raw = Effect.fnUntraced(function* <Substitutions extends Array<unknown>>(
   template: TemplateStringsArrayLike,

package/experimental/Template.ts

@@ -1,4 +1,4 @@
-import { Option, Types, Layer, pipe, String, Effect, Schema as S, Data, SchemaAST, Context } from "effect"
+import { Layer, Effect, Schema as S, Data, Context } from "effect"
 
 import * as Loader from "./Loader.ts"
 
@@ -11,83 +11,75 @@ export class TemplateMisalignedError extends Data.TaggedError("TemplateMisaligne
 
 export class NoSuchTemplateError extends Data.TaggedError("NoSuchTemplateError")<{ url: string }> {}
 
-export interface TemplateClass<Self, Id extends string, A> extends Context.Tag<Self, Template<A>> {
-  new (_: never): Context.TagClassShape<Id, Template<A>>
+export interface TemplateClass<Self, Id extends string, A> extends Context.Service<Self, Template<A>> {
+  new (_: never): Context.ServiceClass.Shape<Id, Template<A>>
 
   readonly layer: Layer.Layer<Self, NoSuchTemplateError | TemplateMisalignedError | Loader.LoaderError, Loader.Loader>
 
   readonly synthesize: (...[value]: A extends undefined ? [] : [value: A]) => Effect.Effect<string, never, Self>
 }
 
-export type Payload = Record<string, S.Schema<any, string> | S.optional<S.Schema<any, string>>>
-
-export declare namespace Payload {
-  export type FromDefinition<P extends Payload | undefined> = P extends infer Q extends Payload
-    ? S.Struct<Q>["Type"]
-    : {}
-}
-
 export const Service =
   <Self>() =>
-  <const Id extends string, const P extends Payload | undefined>(
-    id: Id,
-    {
-      url,
-      payload,
-    }: {
+  <const Id extends string, const P extends S.Struct.Fields>(
+    _id: Id,
+    _config: {
       readonly url: string
-      readonly payload?: P | undefined
+      readonly payload: P
     },
-  ): TemplateClass<Self, Id, Payload.FromDefinition<P>> => {
-    type Make_ = Template<Payload.FromDefinition<P>>
-    type Self_ = TemplateClass<Self, Id, Payload.FromDefinition<P>>
-    const self = Context.Tag(`liminal/Template/${id}`)<Self, Make_>() as never as Types.Mutable<Self_>
-    self.layer = Effect.gen(function* () {
-      const loader = yield* Loader.Loader
-      const template = yield* loader.load(url).pipe(Effect.map(Option.getOrUndefined))
-      if (!template) {
-        return yield* new NoSuchTemplateError({ url })
-      }
-      const [head, ...rest] = pipe(template, String.trim, String.split("{{"))
-      if ((!payload || !Object.keys(payload).length) && !rest.length) {
-        return () => template
-      }
-      const segments = rest.flatMap((part) => {
-        const i = part.indexOf("}}")
-        if (i === -1) {
-          return []
-        }
-        return {
-          key: part.slice(0, i).trim(),
-          tail: part.slice(i + 2),
-        }
-      })
-      const keys = segments.map(({ key }) => key)
-      if (payload) {
-        const keys_ = new Set(keys)
-        const dne = new Set<string>()
-        const schema = S.Struct(payload)
-        const fields = SchemaAST.getPropertySignatures(SchemaAST.encodedBoundAST(schema.ast))
-        for (const field of fields) {
-          if (!field.isOptional && !keys_.has(field.name.toString())) {
-            dne.add(field.name.toString())
-          }
-        }
-        if (dne.size) {
-          return yield* new TemplateMisalignedError({
-            url,
-            keys: [...dne.values()],
-          })
-        }
-      } else if (segments.length) {
-        return yield* new TemplateMisalignedError({ url, keys })
-      }
-      const make: Make_ = (value?) =>
-        value
-          ? head + segments.map(({ key, tail }) => `${(value as Record<typeof key, string>)[key]}${tail}`).join("")
-          : template
-      return make
-    }).pipe(Layer.effect(self))
-    self.synthesize = (...args) => self.pipe(Effect.map((make) => make(...args)))
-    return self as Self_
+  ): TemplateClass<Self, Id, S.Struct<P>["Type"]> => {
+    throw 0
   }
+
+// type Make_ = Template<Payload.FromDefinition<P>>
+// type Self_ = TemplateClass<Self, Id, Payload.FromDefinition<P>>
+// const tag = Context.Service<Self, Make_>()(id)
+// const layer = Effect.gen(function* () {
+//   const loader = yield* Loader.Loader
+//   const template = yield* loader.load(url).pipe(Effect.map(Option.getOrUndefined))
+//   if (!template) {
+//     return yield* new NoSuchTemplateError({ url })
+//   }
+//   const [head, ...rest] = pipe(template, String.trim, String.split("{{"))
+//   if ((!payload || !Object.keys(payload).length) && !rest.length) {
+//     return () => template
+//   }
+//   const segments = rest.flatMap((part) => {
+//     const i = part.indexOf("}}")
+//     if (i === -1) {
+//       return []
+//     }
+//     return {
+//       key: part.slice(0, i).trim(),
+//       tail: part.slice(i + 2),
+//     }
+//   })
+//   const keys = segments.map(({ key }) => key)
+//   if (payload) {
+//     const keys_ = new Set(keys)
+//     const dne = new Set<string>()
+//     const schema = S.Struct(payload)
+//     for (const field of schema.ast.propertySignatures) {
+//       if (!SchemaAST.isOptional(field.type) && !keys_.has(field.name.toString())) {
+//         dne.add(field.name.toString())
+//       }
+//     }
+//     if (dne.size) {
+//       return yield* new TemplateMisalignedError({
+//         url,
+//         keys: [...dne.values()],
+//       })
+//     }
+//   } else if (segments.length) {
+//     return yield* new TemplateMisalignedError({ url, keys })
+//   }
+//   const make: Make_ = (value?) =>
+//     value
+//       ? head + segments.map(({ key, tail }) => `${(value as Record<typeof key, string>)[key]}${tail}`).join("")
+//       : template
+//   return make
+// }).pipe(Layer.effect(tag))
+
+// const synthesize = (...args) => tag.pipe(Effect.map((make) => make(...args)))
+
+// return Object.assign(tag, { synthesize })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "liminal",
-  "version": "0.17.1",
+  "version": "0.17.2",
   "description": "Actors x Effects",
   "bugs": {
     "url": "https://github.com/crosshatch/liminal/issues"
@@ -25,10 +25,6 @@
     "./package.json": "./package.json"
   },
   "peerDependencies": {
-    "@effect-atom/atom": "^0.5.2",
-    "@effect/ai": "^0.33.2",
-    "@effect/experimental": "^0.58.0",
-    "@effect/platform": "^0.94.5",
-    "effect": "^3.19.17"
+    "effect": "4.0.0-beta.50"
   }
 }

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "../tsconfig.base",
+  "extends": "../repos/konfik/tsconfig.base",
   "compilerOptions": {
     "noEmit": false,
     "outDir": "dist"

package/_types.ts

@@ -1,27 +0,0 @@
-import { Schema as S } from "effect"
-
-export type SchemaAll = S.Schema<any, any> | S.Schema<any, never> | S.Schema<never, any> | S.Schema<never, never>
-
-export type PropertySignatureAll<Key extends PropertyKey = PropertyKey> =
-  | S.PropertySignature<S.PropertySignature.Token, any, Key, S.PropertySignature.Token, any, boolean>
-  | S.PropertySignature<S.PropertySignature.Token, never, Key, S.PropertySignature.Token, any, boolean>
-  | S.PropertySignature<S.PropertySignature.Token, any, Key, S.PropertySignature.Token, never, boolean>
-  | S.PropertySignature<S.PropertySignature.Token, never, Key, S.PropertySignature.Token, never, boolean>
-
-export type Field = SchemaAll | PropertySignatureAll
-
-export type Fields = { readonly [x: keyof any]: Field }
-
-export type FieldsRecord = Record<string, Fields>
-
-export declare namespace FieldsRecord {
-  export namespace TaggedMember {
-    export type Type<T extends FieldsRecord, K extends keyof T = keyof T> = {
-      [K_ in K]: { readonly _tag: K_ } & S.Struct<T[K_]>["Type"]
-    }[K]
-
-    export type Encoded<T extends FieldsRecord, K extends keyof T = keyof T> = {
-      [K_ in K]: { readonly _tag: K_ } & S.Struct<T[K_]>["Encoded"]
-    }[K]
-  }
-}

package/dist/_types.d.ts

@@ -1,22 +0,0 @@
-import { Schema as S } from "effect";
-export type SchemaAll = S.Schema<any, any> | S.Schema<any, never> | S.Schema<never, any> | S.Schema<never, never>;
-export type PropertySignatureAll<Key extends PropertyKey = PropertyKey> = S.PropertySignature<S.PropertySignature.Token, any, Key, S.PropertySignature.Token, any, boolean> | S.PropertySignature<S.PropertySignature.Token, never, Key, S.PropertySignature.Token, any, boolean> | S.PropertySignature<S.PropertySignature.Token, any, Key, S.PropertySignature.Token, never, boolean> | S.PropertySignature<S.PropertySignature.Token, never, Key, S.PropertySignature.Token, never, boolean>;
-export type Field = SchemaAll | PropertySignatureAll;
-export type Fields = {
-    readonly [x: keyof any]: Field;
-};
-export type FieldsRecord = Record<string, Fields>;
-export declare namespace FieldsRecord {
-    namespace TaggedMember {
-        type Type<T extends FieldsRecord, K extends keyof T = keyof T> = {
-            [K_ in K]: {
-                readonly _tag: K_;
-            } & S.Struct<T[K_]>["Type"];
-        }[K];
-        type Encoded<T extends FieldsRecord, K extends keyof T = keyof T> = {
-            [K_ in K]: {
-                readonly _tag: K_;
-            } & S.Struct<T[K_]>["Encoded"];
-        }[K];
-    }
-}

package/dist/_types.js

@@ -1,2 +0,0 @@
-import { Schema as S } from "effect";
-//# sourceMappingURL=_types.js.map

package/dist/_types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_types.js","sourceRoot":"","sources":["../_types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA"}