liminal 0.11.1 → 0.13.0

package/util/JsonValue.ts

@@ -0,0 +1,144 @@
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Option from "effect/Option"
+import * as Schema from "effect/Schema"
+import * as SchemaAST from "effect/SchemaAST"
+
+export type JsonValue = null | boolean | number | string | JsonValueArray | JsonValueObject
+
+export type JsonValueArray = Array<JsonValue> | ReadonlyArray<JsonValue>
+
+export type JsonValueObject = { [key: string]: JsonValue }
+
+export const encodeJsonc: <A, I extends JsonValue>(
+  schema: Schema.Schema<A, I>,
+) => (value: A) => Effect.Effect<string> = (schema) => {
+  const encoder = encodeAst(SchemaAST.encodedBoundAST(schema.ast))
+  return (value) => encoder(value, new EncodeJsoncContext(0))
+}
+
+class EncodeJsoncContext {
+  readonly depth: number
+  readonly indentation: string
+  readonly childIndentation: string
+  constructor(depth: number) {
+    this.depth = depth
+    this.indentation = " ".repeat(depth * 2)
+    this.childIndentation = " ".repeat((depth + 1) * 2)
+  }
+
+  next = () => new EncodeJsoncContext(this.depth + 1)
+
+  comment = (type: SchemaAST.AST): string =>
+    Option.match(SchemaAST.getDescriptionAnnotation(type), {
+      onSome: (v) => {
+        v = v.trim()
+        if (v) {
+          return `// ${v}\n${this.childIndentation}`
+        }
+        return ""
+      },
+      onNone: () => "",
+    })
+}
+
+const encodeAst: (
+  ast: SchemaAST.AST,
+  refinement?: SchemaAST.Refinement,
+) => (value: unknown, ctx: EncodeJsoncContext) => Effect.Effect<string> = (ast, refinement) => {
+  switch (ast._tag) {
+    case "TypeLiteral": {
+      return Effect.fnUntraced(function*(value, ctx) {
+        const props = yield* Effect.all(
+          ast.propertySignatures.map(
+            Effect.fnUntraced(function*({ name, type }) {
+              if (typeof name === "symbol") throw 0
+              const child = yield* encodeAst(type)((value as never)[name], ctx.next())
+              return `${ctx.comment(refinement ?? type)}${name}: ${child}`
+            }),
+          ),
+        ).pipe(
+          Effect.map((v) => v.join(`,\n${ctx.childIndentation}`)),
+        )
+        return `{\n${ctx.childIndentation}${props}\n${ctx.indentation}}`
+      })
+    }
+    case "StringKeyword": {
+      return (value) => Effect.succeed(`"${value}"`)
+    }
+    case "BooleanKeyword":
+    case "NumberKeyword": {
+      return (value) => Effect.succeed(String(value))
+    }
+    case "Refinement": {
+      return encodeAst(ast.from, refinement ?? ast)
+    }
+    case "UnknownKeyword":
+    case "AnyKeyword": {
+      return (value, ctx) =>
+        Effect.succeed(
+          JSON
+            .stringify(value, null, 2)
+            .split("\n")
+            .map((line, i) => i ? ctx.indentation.concat(line) : line)
+            .join("\n"),
+        )
+    }
+    case "Union": {
+      const { types } = ast
+      const guards = types.map((ast) =>
+        pipe(
+          ast,
+          Schema.make,
+          Schema.is,
+        )
+      )
+      return (value, ctx) => {
+        for (let i = 0; i < types.length; i++) {
+          const guard = guards[i]!
+          if (guard(value)) {
+            return encodeAst(types[i]!)(value, ctx)
+          }
+        }
+        throw 0
+      }
+    }
+    case "Literal": {
+      const { literal } = ast
+      const v = (() => {
+        switch (typeof literal) {
+          case "boolean":
+          case "number": {
+            return String(literal)
+          }
+          case "string": {
+            return `"${literal}"`
+          }
+        }
+        if (literal === null) {
+          return "null"
+        }
+        console.log({ literal })
+        throw 0
+      })()
+      return () => Effect.succeed(v)
+    }
+    case "TupleType": {
+      const { elements, rest } = ast
+      return (value, ctx) =>
+        Effect.all((elements.length ? elements : rest).map(
+          Effect.fnUntraced(function*(element, i) {
+            const child = yield* encodeAst(element.type)((value as never)[i]!, ctx.next())
+            return `${ctx.comment(refinement ?? element.type)}${child}`
+          }),
+        )).pipe(
+          Effect.map((v) => `[\n${ctx.childIndentation}${v.join(`,\n${ctx.childIndentation}`)}\n${ctx.indentation}]`),
+        )
+    }
+    case "Suspend": {
+      return encodeAst(ast.f())
+    }
+  }
+  console.log({ ast })
+  throw 0
+}

package/util/Sequence.ts

@@ -0,0 +1,9 @@
+import type { Effect } from "effect/Effect"
+
+export type Sequence<I = never, O = never> = <Arg extends Array<Effect<any, any, any>>>(
+  ...steps: Arg
+) => Effect<
+  Arg extends [] ? void : Arg extends [...infer _0, infer L extends Effect<any, any, any>] ? Effect.Success<L> : never,
+  Effect.Error<Arg[number]>,
+  Exclude<Effect.Context<Arg[number]>, I> | O
+>

package/util/Taggable.ts

@@ -0,0 +1,52 @@
+import * as Effect from "effect/Effect"
+import { fixRaw } from "./fixRaw.ts"
+
+/** Append a user message to the conversation. */
+export type Taggable<A, E, R> = <L extends Array<unknown>, E1 = never, R1 = never>(
+  template?:
+    | TemplateStringsArray
+    | string
+    | Effect.Effect<string | undefined, E1, R1>
+    | undefined,
+  ...substitutions: L
+) => Effect.Effect<
+  A,
+  ([ExtractEffect<L>] extends [never] ? never : Effect.Effect.Error<ExtractEffect<L>>) | E | E1,
+  ([ExtractEffect<L>] extends [never] ? never : Effect.Effect.Context<ExtractEffect<L>>) | R | R1
+>
+
+type ExtractEffect<T extends Array<unknown>> = Extract<T[number], Effect.All.EffectAny>
+
+export const normalize: <
+  A0 extends
+    | TemplateStringsArray
+    | string
+    | Effect.Effect<string | undefined, any, any>
+    | undefined,
+  L extends Array<unknown>,
+>(
+  a0: A0,
+  aRest: L,
+) => Effect.Effect<string | (undefined extends A0 ? undefined : never)> = Effect.fnUntraced(function*(a0, aRest) {
+  let a0_: TemplateStringsArray | string | undefined
+  if (Effect.isEffect(a0)) {
+    a0_ = yield* a0 as Effect.Effect<TemplateStringsArray | string | undefined>
+  } else {
+    a0_ = a0
+  }
+  if (!a0_) return undefined as never
+  const aRest_ = yield* Effect.all(
+    aRest.map((v) =>
+      Effect.isEffect(v)
+        ? v
+        : Effect.succeed(v)
+    ),
+  ) as never as Effect.Effect<Array<unknown>>
+  if (typeof a0_ === "string") {
+    if (aRest_.length === 0) {
+      return a0_
+    }
+    return [a0_, ...aRest_].join("")
+  }
+  return fixRaw(a0_, aRest_)
+})

package/util/fixRaw.ts

@@ -0,0 +1,93 @@
+const LEADING_SPACE_RE = /^([ \t]*)/
+const INDENTATION_RE = /^\n([ \t]+)/
+const ESCAPE_SEQ_RE = /\\([`${\\]|\n)/g
+const LAST_INDENTATION_RE = /\n[ \t]+$/
+
+export const fixRaw = (strings: TemplateStringsArray, values: Array<unknown>): string => {
+  const fixedStrings = fixTemplateStrings(strings)
+  const rawArr = fixedStrings.raw
+  const valuesLength = values.length
+
+  const resultParts = new Array(Math.max(1, rawArr.length * 2 - 1))
+  let resultIndex = 0
+
+  for (let i = 0; i < rawArr.length; i++) {
+    const str = rawArr[i] || ""
+    resultParts[resultIndex++] = str
+
+    // Only process values for non-final segments.
+    if (i < valuesLength) {
+      const value = String(values[i])
+
+      // If value has line breaks, we should indent it.
+      if (value.includes("\n")) {
+        const lastNewlineIndex = str.lastIndexOf("\n")
+
+        if (lastNewlineIndex !== -1) {
+          // Extract the indentation after the last newline.
+          const textAfterLastNewline = str.substring(lastNewlineIndex + 1)
+          const leadingSpaceMatch = LEADING_SPACE_RE.exec(textAfterLastNewline)
+          const indentationToApply = leadingSpaceMatch && leadingSpaceMatch[1] ? leadingSpaceMatch[1] : ""
+
+          if (indentationToApply) {
+            // Split the value into lines once.
+            const lines = value.split("\n")
+            const linesLength = lines.length
+
+            // First line doesn't need indentation.
+            resultParts[resultIndex++] = lines[0]
+
+            // Apply indentation to subsequent lines.
+            for (let j = 1; j < linesLength; j++) {
+              resultParts[resultIndex++] = "\n" + indentationToApply + lines[j]
+            }
+            continue
+          }
+        }
+      }
+      // For simple values or when no indentation is needed.
+      resultParts[resultIndex++] = value
+    }
+  }
+
+  // Combine all parts at once
+  return resultParts.slice(0, resultIndex).join("")
+}
+
+export const fixTemplateStrings = (template: TemplateStringsArray): {
+  readonly raw: readonly string[]
+} => {
+  const leadingIndentMatch = INDENTATION_RE.exec(template.raw[0]!)
+  const indentation = leadingIndentMatch?.[1]
+
+  const rawLength = template.raw.length
+  const raw = new Array(rawLength)
+
+  for (let i = 0; i < rawLength; i++) {
+    let str = template.raw[i]!
+    // Only perform common indentation replacements if needed.
+    if (indentation) {
+      // Remove leading newline and indentation in the first segment.
+      if (i === 0) {
+        str = str.slice(indentation.length + 1)
+      }
+      // Use a simple string replacement with a regular expression for better performance.
+      str = str.replaceAll(`\n${indentation}`, "\n")
+    }
+
+    // Replace common escape sequences in a single pass.
+    str = str.replace(ESCAPE_SEQ_RE, (_match, char) => {
+      // Keep the escaped newline replacement separate for clarity.
+      return char === "\n" ? "" : char
+    })
+
+    // Handle trailing spaces only for the last segment.
+    if (indentation && i === rawLength - 1) {
+      str = str.replace(LAST_INDENTATION_RE, "")
+    }
+
+    raw[i] = str
+  }
+
+  return { raw }
+}

package/Sequence.ts

@@ -1,14 +0,0 @@
-import * as Effect from "effect/Effect"
-
-export type Sequence<P = never, R1 = never> = <Arg extends Array<Effect.Effect<any, any, any>>>(
-  ...steps: Arg
-) => Effect.Effect<
-  Arg extends [] ? void
-    : [Arg extends [...infer _0, infer L] ? L : never] extends [Effect.Effect<infer A, infer _E, infer _R>] ? A
-    : never,
-  Arg[number] extends never ? never : [Arg[number]] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never,
-  Exclude<
-    Arg[number] extends never ? never : [Arg[number]] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never,
-    P
-  > | R1
->

package/assistantStruct.ts

@@ -1,34 +0,0 @@
-import type { AiError } from "@effect/ai/AiError"
-import { AssistantMessage, TextPart } from "@effect/ai/AiInput"
-import { AiLanguageModel } from "@effect/ai/AiLanguageModel"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Schema from "effect/Schema"
-import { append } from "./append.ts"
-import { Strand } from "./Strand.ts"
-
-/** Infer a structured assistant message and append its JSON representation to the conversation. */
-export const assistantStruct: {
-  <F extends Record<string, Schema.Schema.AnyNoContext>>(
-    fields: F,
-  ): Effect.Effect<{ [K in keyof F]: Schema.Schema.Type<F[K]> }, AiError, AiLanguageModel | Strand>
-  <O, I extends Record<string, unknown>>(
-    schema: Schema.Schema<O, I, never>,
-  ): Effect.Effect<O, AiError, AiLanguageModel | Strand>
-} = Effect.fnUntraced(
-  function*(schema) {
-    const model = yield* AiLanguageModel
-    const { system, messages } = yield* Strand
-    const { value, text } = yield* model.generateObject({
-      system: Option.getOrUndefined(system),
-      schema: Schema.isSchema(schema) ? schema as Schema.Schema.AnyNoContext : Schema.Struct(schema),
-      prompt: messages,
-    })
-    yield* append(
-      new AssistantMessage({
-        parts: [new TextPart({ text })],
-      }),
-    )
-    return value
-  },
-)

package/dist/Sequence.d.ts

@@ -1,2 +0,0 @@
-import * as Effect from "effect/Effect";
-export type Sequence<P = never, R1 = never> = <Arg extends Array<Effect.Effect<any, any, any>>>(...steps: Arg) => Effect.Effect<Arg extends [] ? void : [Arg extends [...infer _0, infer L] ? L : never] extends [Effect.Effect<infer A, infer _E, infer _R>] ? A : never, Arg[number] extends never ? never : [Arg[number]] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, Exclude<Arg[number] extends never ? never : [Arg[number]] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never, P> | R1>;

package/dist/Sequence.js

@@ -1,2 +0,0 @@
-import * as Effect from "effect/Effect";
-//# sourceMappingURL=Sequence.js.map

package/dist/Sequence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sequence.js","sourceRoot":"","sources":["../Sequence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA"}

package/dist/assistantStruct.js

@@ -1,22 +0,0 @@
-import { AssistantMessage, TextPart } from "@effect/ai/AiInput";
-import { AiLanguageModel } from "@effect/ai/AiLanguageModel";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import { append } from "./append.js";
-import { Strand } from "./Strand.js";
-/** Infer a structured assistant message and append its JSON representation to the conversation. */
-export const assistantStruct = Effect.fnUntraced(function* (schema) {
-    const model = yield* AiLanguageModel;
-    const { system, messages } = yield* Strand;
-    const { value, text } = yield* model.generateObject({
-        system: Option.getOrUndefined(system),
-        schema: Schema.isSchema(schema) ? schema : Schema.Struct(schema),
-        prompt: messages,
-    });
-    yield* append(new AssistantMessage({
-        parts: [new TextPart({ text })],
-    }));
-    return value;
-});
-//# sourceMappingURL=assistantStruct.js.map

package/dist/assistantStruct.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"assistantStruct.js","sourceRoot":"","sources":["../assistantStruct.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAC5D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,mGAAmG;AACnG,MAAM,CAAC,MAAM,eAAe,GAOxB,MAAM,CAAC,UAAU,CACnB,QAAQ,CAAC,EAAC,MAAM;IACd,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,eAAe,CAAA;IACpC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;IAC1C,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC;QAClD,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC;QACrC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAoC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;QAC9F,MAAM,EAAE,QAAQ;KACjB,CAAC,CAAA;IACF,KAAK,CAAC,CAAC,MAAM,CACX,IAAI,gBAAgB,CAAC;QACnB,KAAK,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;KAChC,CAAC,CACH,CAAA;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CACF,CAAA"}

package/dist/internal/JsonValue.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=JsonValue.js.map

package/dist/internal/JsonValue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"JsonValue.js","sourceRoot":"","sources":["../../internal/JsonValue.ts"],"names":[],"mappings":""}

package/dist/internal/Taggable.d.ts

@@ -1,11 +0,0 @@
-export type Taggable<T> = {
-    (value: string): T;
-    (template: TemplateStringsArray, ...substitutions: Array<unknown>): T;
-    (template: string | TemplateStringsArray, ...substitutions: Array<unknown>): T;
-};
-export type TaggableNullable<T> = {
-    (value?: string | undefined): T;
-    (template: TemplateStringsArray, ...substitutions: Array<unknown>): T;
-    (template?: string | TemplateStringsArray | undefined, ...substitutions: Array<unknown>): T;
-};
-export declare const normalize: <A0 extends string | TemplateStringsArray | undefined>(a0: A0, aRest?: Array<unknown>) => string | (undefined extends A0 ? undefined : never);

package/dist/internal/Taggable.js

@@ -1,2 +0,0 @@
-export const normalize = (a0, aRest = []) => a0 ? typeof a0 === "string" ? a0 : String.raw(a0, aRest) : undefined;
-//# sourceMappingURL=Taggable.js.map

package/dist/internal/Taggable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Taggable.js","sourceRoot":"","sources":["../../internal/Taggable.ts"],"names":[],"mappings":"AAYA,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,EAAM,EACN,QAAwB,EAAE,EAC2B,EAAE,CACvD,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAkB,CAAA"}

package/dist/pretty.d.ts

@@ -1,2 +0,0 @@
-import type { LEvent } from "./LEvent.ts";
-export declare const pretty: (event: typeof LEvent["Type"]) => string;

package/dist/pretty.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pretty.js","sourceRoot":"","sources":["../pretty.ts"],"names":[],"mappings":"AAGA,MAAM,IAAI,GAAG,UAAU,CAAA;AACvB,MAAM,KAAK,GAAG,SAAS,CAAA;AACvB,MAAM,IAAI,GAAG,SAAS,CAAA;AACtB,MAAM,OAAO,GAAG,UAAU,CAAA;AAE1B,MAAM,CAAC,MAAM,MAAM,GAA6C,CAAC,KAAK,EAAE,EAAE;IACxE,IAAI,IAAI,GAAG,GAAG,IAAI,GAAG,KAAK,CAAC,IAAI,GAAG,KAAK,EAAE,CAAA;IACzC,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,kBAAkB,CAAC,CAAC,CAAC;YACxB,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YACpD,MAAK;QACP,CAAC;QACD,KAAK,iBAAiB,CAAC,CAAC,CAAC;YACvB,IAAI,IAAI,KAAK,KAAK,CAAC,OAAO,CAAC,MAAM,oBAAoB,CAAA;YACrD,MAAK;QACP,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAA;AAED,MAAM,aAAa,GAAG,CAAC,EAAE,IAAI,EAAE,KAAK,EAAW,EAAU,EAAE;IACzD,IAAI,KAAK,GAAG,EAAE,CAAA;IACd,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,OAAO,EAAE,CAAA;QACvC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;YAClB,KAAK,UAAU,CAAC,CAAC,CAAC;gBAChB,KAAK,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAA;gBACvB,MAAK;YACP,CAAC;YACD,OAAO,CAAC,CAAC,CAAC;gBACR,KAAK,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAA;gBAC3C,MAAK;YACP,CAAC;QACH,CAAC;QACD,KAAK,IAAI,KAAK,CAAA;IAChB,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA"}

package/dist/reduce.d.ts

@@ -1,4 +0,0 @@
-import * as Effect from "effect/Effect";
-import { Strand } from "./Strand.ts";
-/** Sequentially reduce the current strand's messages in chronological order. */
-export declare const reduce: <E, R, E1, R1>(reducer: Effect.Effect<Effect.Effect<void, E1, R1>, E, R>) => Effect.Effect<void, E | E1, R | R1 | Strand>;

package/dist/reduce.js

@@ -1,20 +0,0 @@
-import * as Effect from "effect/Effect";
-import { append } from "./append.js";
-import { clear } from "./clear.js";
-import { Strand } from "./Strand.js";
-import { strand } from "./strand_.js";
-/** Sequentially reduce the current strand's messages in chronological order. */
-export const reduce = Effect.fnUntraced(function* (reducer) {
-    const parent = yield* Strand;
-    if (!parent.messages.length || parent.messages.length === 1)
-        return;
-    const [m0, m1, ...mRest] = parent.messages;
-    let acc = yield* strand(append(m0, m1), reducer);
-    while (mRest.length) {
-        acc = yield* strand(acc, append(mRest.pop()), reducer);
-    }
-    yield* clear;
-    yield* acc;
-    return;
-});
-//# sourceMappingURL=reduce.js.map

package/dist/reduce.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reduce.js","sourceRoot":"","sources":["../reduce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAErC,gFAAgF;AAChF,MAAM,CAAC,MAAM,MAAM,GAMf,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAC,OAAO;IACrC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;IAC5B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAM;IACnE,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,KAAK,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAA;IAC1C,IAAI,GAAG,GAAG,KAAK,CAAC,CAAC,MAAM,CACrB,MAAM,CAAC,EAAG,EAAE,EAAG,CAAC,EAChB,OAAO,CACR,CAAA;IACD,OAAO,KAAK,CAAC,MAAM,EAAE,CAAC;QACpB,GAAG,GAAG,KAAK,CAAC,CAAC,MAAM,CACjB,GAAG,EACH,MAAM,CAAC,KAAK,CAAC,GAAG,EAAG,CAAC,EACpB,OAAO,CACR,CAAA;IACH,CAAC;IACD,KAAK,CAAC,CAAC,KAAK,CAAA;IACZ,KAAK,CAAC,CAAC,GAAG,CAAA;IACV,OAAM;AACR,CAAC,CAAC,CAAA"}

package/dist/sequence_.d.ts

@@ -1,2 +0,0 @@
-import type { Sequence } from "./Sequence";
-export declare const sequence: Sequence;

package/dist/sequence_.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sequence_.js","sourceRoot":"","sources":["../sequence_.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,MAAM,CAAC,MAAM,QAAQ,GAAa,CAAC,GAAG,KAAK,EAAE,EAAE,CAC7C,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE;IAChB,WAAW,EAAE,CAAC;CACf,CAAC,CAAC,IAAI,CACL,MAAM,CAAC,GAAG,CAAC,CAAC,CAAe,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAG,CAAU,CACnD,CAAA"}

package/dist/todo.test.js

@@ -1,3 +0,0 @@
-import { it } from "vitest";
-it("works", () => { });
-//# sourceMappingURL=todo.test.js.map

package/dist/todo.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"todo.test.js","sourceRoot":"","sources":["../todo.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAE3B,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA"}

package/internal/JsonValue.ts

@@ -1,5 +0,0 @@
-export type JsonValue = null | boolean | number | string | JsonValueArray | JsonValueObject
-
-export type JsonValueArray = Array<JsonValue> | ReadonlyArray<JsonValue>
-
-export type JsonValueObject = { [key: string]: JsonValue }

package/internal/Taggable.ts

@@ -1,17 +0,0 @@
-export type Taggable<T> = {
-  (value: string): T
-  (template: TemplateStringsArray, ...substitutions: Array<unknown>): T
-  (template: string | TemplateStringsArray, ...substitutions: Array<unknown>): T
-}
-
-export type TaggableNullable<T> = {
-  (value?: string | undefined): T
-  (template: TemplateStringsArray, ...substitutions: Array<unknown>): T
-  (template?: string | TemplateStringsArray | undefined, ...substitutions: Array<unknown>): T
-}
-
-export const normalize = <A0 extends string | TemplateStringsArray | undefined>(
-  a0: A0,
-  aRest: Array<unknown> = [],
-): string | (undefined extends A0 ? undefined : never) =>
-  a0 ? typeof a0 === "string" ? a0 : String.raw(a0, aRest) : undefined as never

package/reduce.ts

@@ -1,32 +0,0 @@
-import * as Effect from "effect/Effect"
-import { append } from "./append.ts"
-import { clear } from "./clear.ts"
-import { Strand } from "./Strand.ts"
-import { strand } from "./strand_.ts"
-
-/** Sequentially reduce the current strand's messages in chronological order. */
-export const reduce: <E, R, E1, R1>(
-  reducer: Effect.Effect<Effect.Effect<void, E1, R1>, E, R>,
-) => Effect.Effect<
-  void,
-  E | E1,
-  R | R1 | Strand
-> = Effect.fnUntraced(function*(reducer) {
-  const parent = yield* Strand
-  if (!parent.messages.length || parent.messages.length === 1) return
-  const [m0, m1, ...mRest] = parent.messages
-  let acc = yield* strand(
-    append(m0!, m1!),
-    reducer,
-  )
-  while (mRest.length) {
-    acc = yield* strand(
-      acc,
-      append(mRest.pop()!),
-      reducer,
-    )
-  }
-  yield* clear
-  yield* acc
-  return
-})

package/todo.test.ts

@@ -1,3 +0,0 @@
-import { it } from "vitest"
-
-it("works", () => {})

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "extends": "../tsconfig.base",
-  "compilerOptions": {
-    "noEmit": false,
-    "outDir": "dist",
-    "plugins": [
-      {
-        "name": "@effect/language-service",
-        "transform": "@effect/language-service/transform",
-        "namespaceImportPackages": ["effect", "@effect/ai"],
-        "diagnosticSeverity": {
-          "importFromBarrel": "error"
-        }
-      }
-    ]
-  },
-  "include": ["."]
-}