@lionlang/core 0.1.0 → 0.2.0

package/dist/evaluation-Bs36vy1h.d.mts

@@ -0,0 +1,12 @@
+import { r as InnerEnvironment } from "./environment-BQw8BPXl.mjs";
+import { Context } from "effect";
+import * as _$effect_Ref0 from "effect/Ref";
+
+//#region src/services/evaluation.d.ts
+declare const LionEnvironmentService_base: Context.ServiceClass<LionEnvironmentService, "LionEnvironmentService", InnerEnvironment | {
+  readonly bindingsRef: _$effect_Ref0.Ref<Record<string, unknown>>;
+}>;
+declare class LionEnvironmentService extends LionEnvironmentService_base {}
+//#endregion
+export { LionEnvironmentService as t };
+//# sourceMappingURL=evaluation-Bs36vy1h.d.mts.map

package/dist/evaluation-Bs36vy1h.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-Bs36vy1h.d.mts","names":[],"sources":["../src/services/evaluation.ts"],"mappings":";;;;;cAAiC,2BAAA;;;cAGpB,sBAAA,SAA+B,2BAAA"}

package/dist/evaluation-Dwo4KN_D.d.mts

@@ -0,0 +1,9 @@
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "./evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "./evaluation-Bs36vy1h.mjs";
+import { Effect, Schema } from "effect";
+
+//#region src/types/evaluation.d.ts
+type EvaluateResult = Effect.Effect<unknown, Schema.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
+//#endregion
+export { EvaluateResult as t };
+//# sourceMappingURL=evaluation-Dwo4KN_D.d.mts.map

package/dist/evaluation-Dwo4KN_D.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-Dwo4KN_D.d.mts","names":[],"sources":["../src/types/evaluation.ts"],"mappings":";;;;;KAOY,cAAA,GAAiB,MAAA,CAAO,MAAA,UAElC,MAAA,CAAO,WAAA,GAAc,qBAAA,GAAwB,wBAAA,EAC7C,sBAAA"}

package/dist/{json-primitive-DUaaoNff.d.mts → json-primitive-gcv9Q1E4.d.mts}

@@ -1,8 +1,8 @@
 import { Schema } from "effect";
 
 //#region src/schemas/json-primitive.d.ts
-declare const JsonPrimitiveSchema: Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean, typeof Schema.Null]>;
+declare const JsonPrimitiveSchema: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>;
 type JsonPrimitiveType = typeof JsonPrimitiveSchema.Type;
 //#endregion
 export { JsonPrimitiveType as n, JsonPrimitiveSchema as t };
-//# sourceMappingURL=json-primitive-DUaaoNff.d.mts.map
+//# sourceMappingURL=json-primitive-gcv9Q1E4.d.mts.map

package/dist/json-primitive-gcv9Q1E4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-primitive-gcv9Q1E4.d.mts","names":[],"sources":["../src/schemas/json-primitive.ts"],"mappings":";;;cAEa,mBAAA,EAAmB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA,OAAA,EAAA,MAAA,CAAA,IAAA;AAAA,KAOpB,iBAAA,UAA2B,mBAAA,CAAoB,IAAA"}

package/dist/lion-expression-DMR7Psmu.d.mts

@@ -0,0 +1,16 @@
+import { n as JsonPrimitiveType } from "./json-primitive-gcv9Q1E4.mjs";
+import { Schema } from "effect";
+
+//#region src/schemas/lion-expression.d.ts
+type AssumedExpressionType = JsonPrimitiveType | readonly AssumedExpressionType[] | {
+  readonly [key: string]: AssumedExpressionType;
+};
+declare const LionArrayExpressionSchema: Schema.$Array<Schema.suspend<Schema.Codec<AssumedExpressionType, AssumedExpressionType, never, never>>>;
+type LionArrayExpressionType = typeof LionArrayExpressionSchema.Type;
+declare const LionRecordExpressionSchema: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<AssumedExpressionType, AssumedExpressionType, never, never>>>;
+type LionRecordExpressionType = typeof LionRecordExpressionSchema.Type;
+declare const LionExpressionSchema: Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.suspend<Schema.Codec<AssumedExpressionType, AssumedExpressionType, never, never>>>, Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<AssumedExpressionType, AssumedExpressionType, never, never>>>]>;
+type LionExpressionType = typeof LionExpressionSchema.Type;
+//#endregion
+export { LionExpressionType as a, LionExpressionSchema as i, LionArrayExpressionSchema as n, LionRecordExpressionSchema as o, LionArrayExpressionType as r, LionRecordExpressionType as s, AssumedExpressionType as t };
+//# sourceMappingURL=lion-expression-DMR7Psmu.d.mts.map

package/dist/lion-expression-DMR7Psmu.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lion-expression-DMR7Psmu.d.mts","names":[],"sources":["../src/schemas/lion-expression.ts"],"mappings":";;;;KAOY,qBAAA,GACR,iBAAA,YACS,qBAAA;EAAA,UACG,GAAA,WAAc,qBAAA;AAAA;AAAA,cAEjB,yBAAA,EAAyB,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,OAAA,CAAA,MAAA,CAAA,KAAA,CAAA,qBAAA,EAAA,qBAAA;AAAA,KAM1B,uBAAA,UAAiC,yBAAA,CAA0B,IAAA;AAAA,cAK1D,0BAAA,EAA0B,MAAA,CAAA,OAAA,CAAA,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA,OAAA,CAAA,MAAA,CAAA,KAAA,CAAA,qBAAA,EAAA,qBAAA;AAAA,KAY3B,wBAAA,UAAkC,0BAAA,CAA2B,IAAA;AAAA,cAG5D,oBAAA,EAAoB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA,OAAA,EAAA,MAAA,CAAA,IAAA,IAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,OAAA,CAAA,MAAA,CAAA,KAAA,CAAA,qBAAA,EAAA,qBAAA,mBAAA,MAAA,CAAA,OAAA,CAAA,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA,OAAA,CAAA,MAAA,CAAA,KAAA,CAAA,qBAAA,EAAA,qBAAA;AAAA,KAMrB,kBAAA,UAA4B,oBAAA,CAAqB,IAAA"}

package/dist/modules/array.d.mts

@@ -1,18 +1,17 @@
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { Effect, Schema } from "effect";
 
 //#region src/modules/array.d.ts
 declare const module: {
   symbol: symbol;
   make: (...args: unknown[]) => Effect.Effect<unknown[], never, never>;
-  head: (u: unknown) => Effect.Effect<any, _$effect_ParseResult0.ParseError, never>;
-  tail: (u: unknown) => Effect.Effect<any[], _$effect_ParseResult0.ParseError, never>;
-  length: (u: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
-  concat: (a: unknown, b: unknown) => Effect.Effect<any[], _$effect_ParseResult0.ParseError, never>;
-  "includes?": (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  map: (a: unknown, b: unknown) => Effect.Effect<unknown[], _$effect_ParseResult0.ParseError, never>;
-  "flat-map": (a: unknown, b: unknown) => Effect.Effect<unknown[], _$effect_ParseResult0.ParseError, never>;
-  reduce: (a: unknown, b: unknown, c: unknown) => Effect.Effect<any, _$effect_ParseResult0.ParseError, never>;
+  head: (input: unknown) => Effect.Effect<any, Schema.SchemaError, never>;
+  tail: (input: unknown) => Effect.Effect<any[], Schema.SchemaError, never>;
+  length: (input: unknown) => Effect.Effect<number, Schema.SchemaError, never>;
+  concat: (a: unknown, b: unknown) => Effect.Effect<any[], Schema.SchemaError, never>;
+  "includes?": (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  map: (a: unknown, b: unknown) => Effect.Effect<unknown[], Schema.SchemaError, never>;
+  "flat-map": (a: unknown, b: unknown) => Effect.Effect<unknown[], Schema.SchemaError, never>;
+  reduce: (a: unknown, b: unknown, c: unknown) => Effect.Effect<any, Schema.SchemaError, never>;
 };
 //#endregion
 export { module };

package/dist/modules/array.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.mts","names":[],"sources":["../../src/modules/array.ts"],"mappings":";;;;cAGa,MAAA;;gCAGc,MAAA,CAAA,MAAA;2CAAA,qBAAA,CAAA,UAAA"}
+{"version":3,"file":"array.d.mts","names":[],"sources":["../../src/modules/array.ts"],"mappings":";;;cAGa,MAAA;;gCAGc,MAAA,CAAA,MAAA"}

package/dist/modules/array.mjs

@@ -7,15 +7,19 @@ const module = {
 	head: flow(decode(Schema.Array(Schema.Any)), Effect.map(Array.head), Effect.map(Option.getOrThrow)),
 	tail: flow(decode(Schema.Array(Schema.Any)), Effect.map(Array.tail), Effect.map(Option.getOrThrow)),
 	length: flow(decode(Schema.Array(Schema.Any)), Effect.map(Array.length)),
-	concat: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Array(Schema.Any))), Effect.map(Array.flatten)),
-	"includes?": flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)), Effect.map(([list, item]) => Array.contains(list, item))),
-	map: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)), Effect.flatMap(([list, fn]) => Effect.all(Array.map(list, fn)))),
-	"flat-map": flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)), Effect.flatMap(([list, fn]) => pipe(Array.map(list, fn), Effect.all, Effect.map(Array.flatten)))),
+	concat: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Array(Schema.Any)])), Effect.map(Array.flatten)),
+	"includes?": flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Any])), Effect.map(([list, item]) => Array.contains(list, item))),
+	map: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Any])), Effect.flatMap(([list, fn]) => Effect.all(Array.map(list, fn)))),
+	"flat-map": flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Any])), Effect.flatMap(([list, fn]) => pipe(Array.map(list, fn), Effect.all, Effect.map(Array.flatten)))),
 	reduce: flow((a, b, c) => [
 		a,
 		b,
 		c
-	], decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any, Schema.Any)), Effect.flatMap(([list, initial, fn]) => Array.reduce(list, Effect.succeed(initial), (accEffect, item) => Effect.flatMap(accEffect, (acc) => fn(acc, item)))))
+	], decode(Schema.Tuple([
+		Schema.Array(Schema.Any),
+		Schema.Any,
+		Schema.Any
+	])), Effect.flatMap(([list, initial, fn]) => Array.reduce(list, Effect.succeed(initial), (accEffect, item) => Effect.flatMap(accEffect, (acc) => fn(acc, item)))))
 };
 //#endregion
 export { module };

package/dist/modules/array.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array.mjs","names":["Arr"],"sources":["../../src/modules/array.ts"],"sourcesContent":["import { Array as Arr, Effect, flow, Option, pipe, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"array\"),\n\n  make: (...args: unknown[]) => Effect.succeed(args),\n\n  head: flow(\n    decode(Schema.Array(Schema.Any)),\n    Effect.map(Arr.head),\n    Effect.map(Option.getOrThrow)\n  ),\n\n  tail: flow(\n    decode(Schema.Array(Schema.Any)),\n    Effect.map(Arr.tail),\n    Effect.map(Option.getOrThrow)\n  ),\n\n  length: flow(decode(Schema.Array(Schema.Any)), Effect.map(Arr.length)),\n\n  concat: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Array(Schema.Any))),\n    Effect.map(Arr.flatten)\n  ),\n\n  \"includes?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)),\n    Effect.map(([list, item]) => Arr.contains(list, item))\n  ),\n\n  map: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)),\n    Effect.flatMap(([list, fn]) =>\n      Effect.all(Arr.map(list, fn) as Effect.Effect<unknown>[])\n    )\n  ),\n\n  \"flat-map\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any)),\n    Effect.flatMap(([list, fn]) =>\n      pipe(\n        Arr.map(list, fn) as Effect.Effect<unknown[]>[],\n        Effect.all,\n        Effect.map(Arr.flatten)\n      )\n    )\n  ),\n\n  reduce: flow(\n    (a: unknown, b: unknown, c: unknown) => [a, b, c],\n    decode(Schema.Tuple(Schema.Array(Schema.Any), Schema.Any, Schema.Any)),\n    Effect.flatMap(([list, initial, fn]) =>\n      Arr.reduce(list, Effect.succeed(initial), (accEffect, item) =>\n        Effect.flatMap(accEffect, (acc) =>\n          (fn as (acc: unknown, item: unknown) => Effect.Effect<unknown>)(\n            acc,\n            item\n          )\n        )\n      )\n    )\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,QAAQ;CAEvB,OAAO,GAAG,SAAoB,OAAO,QAAQ,KAAK;CAElD,MAAM,KACJ,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAChC,OAAO,IAAIA,MAAI,KAAK,EACpB,OAAO,IAAI,OAAO,WAAW,CAC9B;CAED,MAAM,KACJ,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAChC,OAAO,IAAIA,MAAI,KAAK,EACpB,OAAO,IAAI,OAAO,WAAW,CAC9B;CAED,QAAQ,KAAK,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAAE,OAAO,IAAIA,MAAI,OAAO,CAAC;CAEtE,QAAQ,MACL,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,MAAM,OAAO,IAAI,CAAC,CAAC,EACxE,OAAO,IAAIA,MAAI,QAAQ,CACxB;CAED,aAAa,MACV,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,EAC1D,OAAO,KAAK,CAAC,MAAM,UAAUA,MAAI,SAAS,MAAM,KAAK,CAAC,CACvD;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,EAC1D,OAAO,SAAS,CAAC,MAAM,QACrB,OAAO,IAAIA,MAAI,IAAI,MAAM,GAAG,CAA6B,CAC1D,CACF;CAED,YAAY,MACT,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,EAC1D,OAAO,SAAS,CAAC,MAAM,QACrB,KACEA,MAAI,IAAI,MAAM,GAAG,EACjB,OAAO,KACP,OAAO,IAAIA,MAAI,QAAQ,CACxB,CACF,CACF;CAED,QAAQ,MACL,GAAY,GAAY,MAAe;EAAC;EAAG;EAAG;EAAE,EACjD,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,KAAK,OAAO,IAAI,CAAC,EACtE,OAAO,SAAS,CAAC,MAAM,SAAS,QAC9BA,MAAI,OAAO,MAAM,OAAO,QAAQ,QAAQ,GAAG,WAAW,SACpD,OAAO,QAAQ,YAAY,QACxB,GACC,KACA,KACD,CACF,CACF,CACF,CACF;CACF"}
+{"version":3,"file":"array.mjs","names":["Arr"],"sources":["../../src/modules/array.ts"],"sourcesContent":["import { Array as Arr, Effect, flow, Option, pipe, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"array\"),\n\n  make: (...args: unknown[]) => Effect.succeed(args),\n\n  head: flow(\n    decode(Schema.Array(Schema.Any)),\n    Effect.map(Arr.head),\n    Effect.map(Option.getOrThrow)\n  ),\n\n  tail: flow(\n    decode(Schema.Array(Schema.Any)),\n    Effect.map(Arr.tail),\n    Effect.map(Option.getOrThrow)\n  ),\n\n  length: flow(decode(Schema.Array(Schema.Any)), Effect.map(Arr.length)),\n\n  concat: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Array(Schema.Any)])),\n    Effect.map(Arr.flatten)\n  ),\n\n  \"includes?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Any])),\n    Effect.map(([list, item]) => Arr.contains(list, item))\n  ),\n\n  map: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Any])),\n    Effect.flatMap(([list, fn]) =>\n      Effect.all(Arr.map(list, fn) as Effect.Effect<unknown>[])\n    )\n  ),\n\n  \"flat-map\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Any])),\n    Effect.flatMap(([list, fn]) =>\n      pipe(\n        Arr.map(list, fn) as Effect.Effect<unknown[]>[],\n        Effect.all,\n        Effect.map(Arr.flatten)\n      )\n    )\n  ),\n\n  reduce: flow(\n    (a: unknown, b: unknown, c: unknown) => [a, b, c],\n    decode(Schema.Tuple([Schema.Array(Schema.Any), Schema.Any, Schema.Any])),\n    Effect.flatMap(([list, initial, fn]) =>\n      Arr.reduce(list, Effect.succeed(initial), (accEffect, item) =>\n        Effect.flatMap(accEffect, (acc) =>\n          (fn as (acc: unknown, item: unknown) => Effect.Effect<unknown>)(\n            acc,\n            item\n          )\n        )\n      )\n    )\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,QAAQ;CAEvB,OAAO,GAAG,SAAoB,OAAO,QAAQ,KAAK;CAElD,MAAM,KACJ,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAChC,OAAO,IAAIA,MAAI,KAAK,EACpB,OAAO,IAAI,OAAO,WAAW,CAC9B;CAED,MAAM,KACJ,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAChC,OAAO,IAAIA,MAAI,KAAK,EACpB,OAAO,IAAI,OAAO,WAAW,CAC9B;CAED,QAAQ,KAAK,OAAO,OAAO,MAAM,OAAO,IAAI,CAAC,EAAE,OAAO,IAAIA,MAAI,OAAO,CAAC;CAEtE,QAAQ,MACL,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,MAAM,OAAO,IAAI,CAAC,CAAC,CAAC,EAC1E,OAAO,IAAIA,MAAI,QAAQ,CACxB;CAED,aAAa,MACV,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,CAAC,EAC5D,OAAO,KAAK,CAAC,MAAM,UAAUA,MAAI,SAAS,MAAM,KAAK,CAAC,CACvD;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,CAAC,EAC5D,OAAO,SAAS,CAAC,MAAM,QACrB,OAAO,IAAIA,MAAI,IAAI,MAAM,GAAG,CAA6B,CAC1D,CACF;CAED,YAAY,MACT,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,MAAM,OAAO,IAAI,EAAE,OAAO,IAAI,CAAC,CAAC,EAC5D,OAAO,SAAS,CAAC,MAAM,QACrB,KACEA,MAAI,IAAI,MAAM,GAAG,EACjB,OAAO,KACP,OAAO,IAAIA,MAAI,QAAQ,CACxB,CACF,CACF;CAED,QAAQ,MACL,GAAY,GAAY,MAAe;EAAC;EAAG;EAAG;EAAE,EACjD,OAAO,OAAO,MAAM;EAAC,OAAO,MAAM,OAAO,IAAI;EAAE,OAAO;EAAK,OAAO;EAAI,CAAC,CAAC,EACxE,OAAO,SAAS,CAAC,MAAM,SAAS,QAC9BA,MAAI,OAAO,MAAM,OAAO,QAAQ,QAAQ,GAAG,WAAW,SACpD,OAAO,QAAQ,YAAY,QACxB,GACC,KACA,KACD,CACF,CACF,CACF,CACF;CACF"}

package/dist/modules/boolean.d.mts

@@ -1,16 +1,15 @@
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { Effect, Schema } from "effect";
 
 //#region src/modules/boolean.d.ts
 declare const module: {
   symbol: symbol;
-  "equals?": (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  not: (u: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  and: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  or: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  xor: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  nand: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  nor: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
+  "equals?": (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  not: (input: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  and: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  or: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  xor: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  nand: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  nor: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
 };
 //#endregion
 export { module };

package/dist/modules/boolean.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"boolean.d.mts","names":[],"sources":["../../src/modules/boolean.ts"],"mappings":";;;;cAGa,MAAA;;gEAwCZ,qBAAA,CAAA,UAAA"}
+{"version":3,"file":"boolean.d.mts","names":[],"sources":["../../src/modules/boolean.ts"],"mappings":";;;cAGa,MAAA"}

package/dist/modules/boolean.mjs

@@ -3,13 +3,13 @@ import { Boolean, Effect, Schema, flow } from "effect";
 //#region src/modules/boolean.ts
 const module = {
 	symbol: Symbol("boolean"),
-	"equals?": flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => a === b)),
+	"equals?": flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])), Effect.map(([a, b]) => a === b)),
 	not: flow(decode(Schema.Boolean), Effect.map(Boolean.not)),
-	and: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.and(a, b))),
-	or: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.or(a, b))),
-	xor: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.xor(a, b))),
-	nand: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.nand(a, b))),
-	nor: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)), Effect.map(([a, b]) => Boolean.nor(a, b)))
+	and: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])), Effect.map(([a, b]) => Boolean.and(a, b))),
+	or: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])), Effect.map(([a, b]) => Boolean.or(a, b))),
+	xor: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])), Effect.map(([a, b]) => Boolean.xor(a, b))),
+	nand: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])), Effect.map(([a, b]) => Boolean.nand(a, b))),
+	nor: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])), Effect.map(([a, b]) => Boolean.nor(a, b)))
 };
 //#endregion
 export { module };

package/dist/modules/boolean.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"boolean.mjs","names":["Bool"],"sources":["../../src/modules/boolean.ts"],"sourcesContent":["import { Boolean as Bool, Effect, flow, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"boolean\"),\n\n  \"equals?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => a === b)\n  ),\n\n  not: flow(decode(Schema.Boolean), Effect.map(Bool.not)),\n\n  and: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.and(a, b))\n  ),\n\n  or: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.or(a, b))\n  ),\n\n  xor: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.xor(a, b))\n  ),\n\n  nand: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.nand(a, b))\n  ),\n\n  nor: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Boolean, Schema.Boolean)),\n    Effect.map(([a, b]) => Bool.nor(a, b))\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,UAAU;CAEzB,WAAW,MACR,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,MAAM,EAAE,CAChC;CAED,KAAK,KAAK,OAAO,OAAO,QAAQ,EAAE,OAAO,IAAIA,QAAK,IAAI,CAAC;CAEvD,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CAED,IAAI,MACD,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,GAAG,GAAG,EAAE,CAAC,CACtC;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CAED,MAAM,MACH,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,KAAK,GAAG,EAAE,CAAC,CACxC;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,SAAS,OAAO,QAAQ,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CACF"}
+{"version":3,"file":"boolean.mjs","names":["Bool"],"sources":["../../src/modules/boolean.ts"],"sourcesContent":["import { Boolean as Bool, Effect, flow, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"boolean\"),\n\n  \"equals?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])),\n    Effect.map(([a, b]) => a === b)\n  ),\n\n  not: flow(decode(Schema.Boolean), Effect.map(Bool.not)),\n\n  and: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])),\n    Effect.map(([a, b]) => Bool.and(a, b))\n  ),\n\n  or: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])),\n    Effect.map(([a, b]) => Bool.or(a, b))\n  ),\n\n  xor: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])),\n    Effect.map(([a, b]) => Bool.xor(a, b))\n  ),\n\n  nand: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])),\n    Effect.map(([a, b]) => Bool.nand(a, b))\n  ),\n\n  nor: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Boolean, Schema.Boolean])),\n    Effect.map(([a, b]) => Bool.nor(a, b))\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,UAAU;CAEzB,WAAW,MACR,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,SAAS,OAAO,QAAQ,CAAC,CAAC,EACtD,OAAO,KAAK,CAAC,GAAG,OAAO,MAAM,EAAE,CAChC;CAED,KAAK,KAAK,OAAO,OAAO,QAAQ,EAAE,OAAO,IAAIA,QAAK,IAAI,CAAC;CAEvD,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,SAAS,OAAO,QAAQ,CAAC,CAAC,EACtD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CAED,IAAI,MACD,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,SAAS,OAAO,QAAQ,CAAC,CAAC,EACtD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,GAAG,GAAG,EAAE,CAAC,CACtC;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,SAAS,OAAO,QAAQ,CAAC,CAAC,EACtD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CAED,MAAM,MACH,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,SAAS,OAAO,QAAQ,CAAC,CAAC,EACtD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,KAAK,GAAG,EAAE,CAAC,CACxC;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,SAAS,OAAO,QAAQ,CAAC,CAAC,EACtD,OAAO,KAAK,CAAC,GAAG,OAAOA,QAAK,IAAI,GAAG,EAAE,CAAC,CACvC;CACF"}

package/dist/modules/console.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"console.mjs","names":[],"sources":["../../src/modules/console.ts"],"sourcesContent":["import { Console, Effect } from \"effect\";\n\nexport const module = {\n  log: (message: string) =>\n    Console.log(message).pipe(Effect.map(() => message)),\n  \n  \"log-json\": (message: unknown) =>\n    Console.log(JSON.stringify(message, null, 2)).pipe(\n      Effect.map(() => JSON.stringify(message, null, 2))\n    ),\n};\n"],"mappings":";;AAEA,MAAa,SAAS;CACpB,MAAM,YACJ,QAAQ,IAAI,QAAQ,CAAC,KAAK,OAAO,UAAU,QAAQ,CAAC;CAEtD,aAAa,YACX,QAAQ,IAAI,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC,CAAC,KAC5C,OAAO,UAAU,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC,CACnD;CACJ"}
+{"version":3,"file":"console.mjs","names":[],"sources":["../../src/modules/console.ts"],"sourcesContent":["import { Console, Effect } from \"effect\";\n\nexport const module = {\n  log: (message: string) =>\n    Console.log(message).pipe(Effect.map(() => message)),\n\n  \"log-json\": (message: unknown) =>\n    Console.log(JSON.stringify(message, null, 2)).pipe(\n      Effect.map(() => JSON.stringify(message, null, 2))\n    ),\n};\n"],"mappings":";;AAEA,MAAa,SAAS;CACpB,MAAM,YACJ,QAAQ,IAAI,QAAQ,CAAC,KAAK,OAAO,UAAU,QAAQ,CAAC;CAEtD,aAAa,YACX,QAAQ,IAAI,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC,CAAC,KAC5C,OAAO,UAAU,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC,CACnD;CACJ"}

package/dist/modules/lib/shared.d.mts

@@ -1,9 +1,8 @@
 import { Schema } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
 import * as _$effect_Effect0 from "effect/Effect";
 
 //#region src/modules/lib/shared.d.ts
-declare const decode: <A, B, C>(s: Schema.Schema<A, B, C>) => (u: unknown) => _$effect_Effect0.Effect<A, _$effect_ParseResult0.ParseError, C>;
+declare const decode: <A>(schema: Schema.Decoder<A>) => (input: unknown) => _$effect_Effect0.Effect<A, Schema.SchemaError, never>;
 //#endregion
 export { decode };
 //# sourceMappingURL=shared.d.mts.map

package/dist/modules/lib/shared.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.mts","names":[],"sources":["../../../src/modules/lib/shared.ts"],"mappings":";;;;;cAEa,MAAA,YAAmB,CAAA,EAAG,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,OACpD,CAAA,cAAU,gBAAA,CAAA,MAAA,CAAA,CAAA,EAAA,qBAAA,CAAA,UAAA,EAAA,CAAA"}
+{"version":3,"file":"shared.d.mts","names":[],"sources":["../../../src/modules/lib/shared.ts"],"mappings":";;;;cAEa,MAAA,MACP,MAAA,EAAQ,MAAA,CAAO,OAAA,CAAQ,CAAA,OAC1B,KAAA,cAAc,gBAAA,CAAA,MAAA,CAAA,CAAA,EAAA,MAAA,CAAA,WAAA"}

package/dist/modules/lib/shared.mjs

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 //#region src/modules/lib/shared.ts
-const decode = (s) => (u) => Schema.decodeUnknown(s)(u);
+const decode = (schema) => (input) => Schema.decodeUnknownEffect(schema)(input);
 //#endregion
 export { decode };
 

package/dist/modules/lib/shared.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"shared.mjs","names":[],"sources":["../../../src/modules/lib/shared.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const decode = <A, B, C>(s: Schema.Schema<A, B, C>) =>\n  (u: unknown) => Schema.decodeUnknown(s)(u);\n"],"mappings":";;AAEA,MAAa,UAAmB,OAC7B,MAAe,OAAO,cAAc,EAAE,CAAC,EAAE"}
+{"version":3,"file":"shared.mjs","names":[],"sources":["../../../src/modules/lib/shared.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const decode =\n  <A>(schema: Schema.Decoder<A>) =>\n  (input: unknown) =>\n    Schema.decodeUnknownEffect(schema)(input);\n"],"mappings":";;AAEA,MAAa,UACP,YACH,UACC,OAAO,oBAAoB,OAAO,CAAC,MAAM"}

package/dist/modules/number.d.mts

@@ -1,18 +1,17 @@
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { Effect, Schema } from "effect";
 
 //#region src/modules/number.d.ts
 declare const module: {
   symbol: symbol;
-  "equals?": (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  lessThan: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  greaterThan: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  lessThanOrEqualTo: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  greaterThanOrEqualTo: (a: unknown, b: unknown) => Effect.Effect<boolean, _$effect_ParseResult0.ParseError, never>;
-  add: (a: unknown, b: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
-  subtract: (a: unknown, b: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
-  multiply: (a: unknown, b: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
-  divide: (a: unknown, b: unknown) => Effect.Effect<number, _$effect_ParseResult0.ParseError, never>;
+  "equals?": (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  lessThan: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  greaterThan: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  lessThanOrEqualTo: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  greaterThanOrEqualTo: (a: unknown, b: unknown) => Effect.Effect<boolean, Schema.SchemaError, never>;
+  add: (a: unknown, b: unknown) => Effect.Effect<number, Schema.SchemaError, never>;
+  subtract: (a: unknown, b: unknown) => Effect.Effect<number, Schema.SchemaError, never>;
+  multiply: (a: unknown, b: unknown) => Effect.Effect<number, Schema.SchemaError, never>;
+  divide: (a: unknown, b: unknown) => Effect.Effect<number, Schema.SchemaError, never>;
 };
 //#endregion
 export { module };

package/dist/modules/number.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"number.d.mts","names":[],"sources":["../../src/modules/number.ts"],"mappings":";;;;cAGa,MAAA;;gEAwDZ,qBAAA,CAAA,UAAA"}
+{"version":3,"file":"number.d.mts","names":[],"sources":["../../src/modules/number.ts"],"mappings":";;;cAGa,MAAA"}

package/dist/modules/number.mjs

@@ -3,15 +3,15 @@ import { Effect, Schema, flow } from "effect";
 //#region src/modules/number.ts
 const module = {
 	symbol: Symbol("number"),
-	"equals?": flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a === b)),
-	lessThan: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a < b)),
-	greaterThan: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a > b)),
-	lessThanOrEqualTo: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a <= b)),
-	greaterThanOrEqualTo: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a >= b)),
-	add: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a + b)),
-	subtract: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a - b)),
-	multiply: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a * b)),
-	divide: flow((a, b) => [a, b], decode(Schema.Tuple(Schema.Number, Schema.Number)), Effect.map(([a, b]) => a / b))
+	"equals?": flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a === b)),
+	lessThan: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a < b)),
+	greaterThan: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a > b)),
+	lessThanOrEqualTo: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a <= b)),
+	greaterThanOrEqualTo: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a >= b)),
+	add: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a + b)),
+	subtract: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a - b)),
+	multiply: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a * b)),
+	divide: flow((a, b) => [a, b], decode(Schema.Tuple([Schema.Number, Schema.Number])), Effect.map(([a, b]) => a / b))
 };
 //#endregion
 export { module };

package/dist/modules/number.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"number.mjs","names":[],"sources":["../../src/modules/number.ts"],"sourcesContent":["import { Effect, flow, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"number\"),\n\n  \"equals?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a === b)\n  ),\n\n  lessThan: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a < b)\n  ),\n\n  greaterThan: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a > b)\n  ),\n\n  lessThanOrEqualTo: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a <= b)\n  ),\n\n  greaterThanOrEqualTo: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a >= b)\n  ),\n\n  add: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a + b)\n  ),\n\n  subtract: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a - b)\n  ),\n\n  multiply: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a * b)\n  ),\n\n  divide: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple(Schema.Number, Schema.Number)),\n    Effect.map(([a, b]) => a / b)\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,SAAS;CAExB,WAAW,MACR,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,MAAM,EAAE,CAChC;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,aAAa,MACV,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,mBAAmB,MAChB,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,KAAK,EAAE,CAC/B;CAED,sBAAsB,MACnB,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,KAAK,EAAE,CAC/B;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,QAAQ,MACL,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,OAAO,QAAQ,OAAO,OAAO,CAAC,EAClD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CACF"}
+{"version":3,"file":"number.mjs","names":[],"sources":["../../src/modules/number.ts"],"sourcesContent":["import { Effect, flow, Schema } from \"effect\";\nimport { decode } from \"@/modules/lib/shared\";\n\nexport const module = {\n  symbol: Symbol(\"number\"),\n\n  \"equals?\": flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a === b)\n  ),\n\n  lessThan: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a < b)\n  ),\n\n  greaterThan: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a > b)\n  ),\n\n  lessThanOrEqualTo: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a <= b)\n  ),\n\n  greaterThanOrEqualTo: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a >= b)\n  ),\n\n  add: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a + b)\n  ),\n\n  subtract: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a - b)\n  ),\n\n  multiply: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a * b)\n  ),\n\n  divide: flow(\n    (a: unknown, b: unknown) => [a, b],\n    decode(Schema.Tuple([Schema.Number, Schema.Number])),\n    Effect.map(([a, b]) => a / b)\n  ),\n};\n"],"mappings":";;;AAGA,MAAa,SAAS;CACpB,QAAQ,OAAO,SAAS;CAExB,WAAW,MACR,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,MAAM,EAAE,CAChC;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,aAAa,MACV,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,mBAAmB,MAChB,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,KAAK,EAAE,CAC/B;CAED,sBAAsB,MACnB,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,KAAK,EAAE,CAC/B;CAED,KAAK,MACF,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,UAAU,MACP,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CAED,QAAQ,MACL,GAAY,MAAe,CAAC,GAAG,EAAE,EAClC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,EACpD,OAAO,KAAK,CAAC,GAAG,OAAO,IAAI,EAAE,CAC9B;CACF"}

package/dist/modules/object.d.mts

@@ -1,80 +1,60 @@
 import { Effect, Schema } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import * as _$effect_Cause0 from "effect/Cause";
 
 //#region src/modules/object.d.ts
-declare const NotAnObjectError_base: Schema.TaggedErrorClass<NotAnObjectError, "NotAnObjectError", {
-  readonly _tag: Schema.tag<"NotAnObjectError">;
-} & {
-  actual: typeof Schema.Unknown;
-}>;
+declare const NotAnObjectError_base: Schema.Class<NotAnObjectError, Schema.TaggedStruct<"NotAnObjectError", {
+  readonly actual: Schema.Unknown;
+}>, _$effect_Cause0.YieldableError>;
 declare class NotAnObjectError extends NotAnObjectError_base {}
-declare const KeyNotFoundError_base: Schema.TaggedErrorClass<KeyNotFoundError, "KeyNotFoundError", {
-  readonly _tag: Schema.tag<"KeyNotFoundError">;
-} & {
-  key: typeof Schema.String;
-}>;
+declare const KeyNotFoundError_base: Schema.Class<KeyNotFoundError, Schema.TaggedStruct<"KeyNotFoundError", {
+  readonly key: Schema.String;
+}>, _$effect_Cause0.YieldableError>;
 declare class KeyNotFoundError extends KeyNotFoundError_base {}
-declare const NotAFunctionError_base: Schema.TaggedErrorClass<NotAFunctionError, "NotAFunctionError", {
-  readonly _tag: Schema.tag<"NotAFunctionError">;
-} & {
-  key: typeof Schema.String;
-  actual: typeof Schema.Unknown;
-}>;
+declare const NotAFunctionError_base: Schema.Class<NotAFunctionError, Schema.TaggedStruct<"NotAFunctionError", {
+  readonly key: Schema.String;
+  readonly actual: Schema.Unknown;
+}>, _$effect_Cause0.YieldableError>;
 declare class NotAFunctionError extends NotAFunctionError_base {}
-declare const NotAConstructorError_base: Schema.TaggedErrorClass<NotAConstructorError, "NotAConstructorError", {
-  readonly _tag: Schema.tag<"NotAConstructorError">;
-} & {
-  actual: typeof Schema.Unknown;
-}>;
+declare const NotAConstructorError_base: Schema.Class<NotAConstructorError, Schema.TaggedStruct<"NotAConstructorError", {
+  readonly actual: Schema.Unknown;
+}>, _$effect_Cause0.YieldableError>;
 declare class NotAConstructorError extends NotAConstructorError_base {}
-declare const PathTraversalError_base: Schema.TaggedErrorClass<PathTraversalError, "PathTraversalError", {
-  readonly _tag: Schema.tag<"PathTraversalError">;
-} & {
-  path: typeof Schema.String;
-  key: typeof Schema.String;
-  current: typeof Schema.Unknown;
-}>;
+declare const PathTraversalError_base: Schema.Class<PathTraversalError, Schema.TaggedStruct<"PathTraversalError", {
+  readonly path: Schema.String;
+  readonly key: Schema.String;
+  readonly current: Schema.Unknown;
+}>, _$effect_Cause0.YieldableError>;
 declare class PathTraversalError extends PathTraversalError_base {}
-declare const EmptyPathError_base: Schema.TaggedErrorClass<EmptyPathError, "EmptyPathError", {
-  readonly _tag: Schema.tag<"EmptyPathError">;
-} & {
-  path: typeof Schema.String;
-}>;
+declare const EmptyPathError_base: Schema.Class<EmptyPathError, Schema.TaggedStruct<"EmptyPathError", {
+  readonly path: Schema.String;
+}>, _$effect_Cause0.YieldableError>;
 declare class EmptyPathError extends EmptyPathError_base {}
-declare const MethodNotFoundError_base: Schema.TaggedErrorClass<MethodNotFoundError, "MethodNotFoundError", {
-  readonly _tag: Schema.tag<"MethodNotFoundError">;
-} & {
-  path: typeof Schema.String;
-  methodKey: typeof Schema.String;
-  actual: typeof Schema.Unknown;
-}>;
+declare const MethodNotFoundError_base: Schema.Class<MethodNotFoundError, Schema.TaggedStruct<"MethodNotFoundError", {
+  readonly path: Schema.String;
+  readonly methodKey: Schema.String;
+  readonly actual: Schema.Unknown;
+}>, _$effect_Cause0.YieldableError>;
 declare class MethodNotFoundError extends MethodNotFoundError_base {}
-declare const IndexOutOfBoundsError_base: Schema.TaggedErrorClass<IndexOutOfBoundsError, "IndexOutOfBoundsError", {
-  readonly _tag: Schema.tag<"IndexOutOfBoundsError">;
-} & {
-  index: typeof Schema.Number;
-  length: typeof Schema.Number;
-}>;
+declare const IndexOutOfBoundsError_base: Schema.Class<IndexOutOfBoundsError, Schema.TaggedStruct<"IndexOutOfBoundsError", {
+  readonly index: Schema.Number;
+  readonly length: Schema.Number;
+}>, _$effect_Cause0.YieldableError>;
 declare class IndexOutOfBoundsError extends IndexOutOfBoundsError_base {}
-declare const NotAnArrayError_base: Schema.TaggedErrorClass<NotAnArrayError, "NotAnArrayError", {
-  readonly _tag: Schema.tag<"NotAnArrayError">;
-} & {
-  actual: typeof Schema.Unknown;
-}>;
+declare const NotAnArrayError_base: Schema.Class<NotAnArrayError, Schema.TaggedStruct<"NotAnArrayError", {
+  readonly actual: Schema.Unknown;
+}>, _$effect_Cause0.YieldableError>;
 declare class NotAnArrayError extends NotAnArrayError_base {}
-declare const InvalidPathError_base: Schema.TaggedErrorClass<InvalidPathError, "InvalidPathError", {
-  readonly _tag: Schema.tag<"InvalidPathError">;
-} & {
-  path: typeof Schema.Unknown;
-}>;
+declare const InvalidPathError_base: Schema.Class<InvalidPathError, Schema.TaggedStruct<"InvalidPathError", {
+  readonly path: Schema.Unknown;
+}>, _$effect_Cause0.YieldableError>;
 declare class InvalidPathError extends InvalidPathError_base {}
 declare const module: {
   symbol: symbol;
   get: (obj: unknown, key: string) => Effect.Effect<unknown, NotAnObjectError, never>;
   "get-path": (obj: unknown, path: string) => Effect.Effect<unknown, NotAnObjectError | InvalidPathError | PathTraversalError | NotAnArrayError | IndexOutOfBoundsError | KeyNotFoundError, never>;
   "json-stringify": (obj: unknown, replacer: Parameters<typeof JSON.stringify>[1], space: number) => Effect.Effect<string, NotAnObjectError, never>;
-  keys: (obj: unknown) => Effect.Effect<string[], _$effect_ParseResult0.ParseError, never>;
-  values: (obj: unknown) => Effect.Effect<unknown[], _$effect_ParseResult0.ParseError, never>;
+  keys: (obj: unknown) => Effect.Effect<string[], Schema.SchemaError, never>;
+  values: (obj: unknown) => Effect.Effect<unknown[], Schema.SchemaError, never>;
   new: (classRef: unknown, ...args: unknown[]) => Effect.Effect<unknown, NotAConstructorError, never>;
   "get-method": (obj: unknown, key: unknown) => Effect.Effect<any, NotAnObjectError | NotAFunctionError, never>;
   "call-method": (obj: unknown, key: unknown, ...args: unknown[]) => Effect.Effect<any, NotAFunctionError, never>;

package/dist/modules/object.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.mts","names":[],"sources":["../../src/modules/object.ts"],"mappings":";;;;cAAsD,qBAAA;;;;;cAEhD,gBAAA,SAAyB,qBAAA;AAAA,cAEkB,qBAAA;;;;;cAE3C,gBAAA,SAAyB,qBAAA;AAAA,cAEc,sBAAA;;;;;;cAEvC,iBAAA,SAA0B,sBAAA;AAAA,cAEsC,yBAAA;;;;;cAEhE,oBAAA,SAA6B,yBAAA;AAAA,cAEkB,uBAAA;;;;;;;cAE/C,kBAAA,SAA2B,uBAAA;AAAA,cAM/B,mBAAA;;;;;cAEI,cAAA,SAAuB,mBAAA;AAAA,cAEe,wBAAA;;;;;;;cAEtC,mBAAA,SAA4B,wBAAA;AAAA,cAMhC,0BAAA;;;;;;cAEI,qBAAA,SAA8B,0BAAA;AAAA,cAKlC,oBAAA;;;;;cAEI,eAAA,SAAwB,oBAAA;AAAA,cAEkB,qBAAA;;;;;cAE1C,gBAAA,SAAyB,qBAAA;AAAA,cAkGlB,MAAA;;sBAGO,GAAA,aAAa,MAAA,CAAA,MAAA,UAAA,gBAAA;6BAQN,IAAA,aAAc,MAAA,CAAA,MAAA,UAAA,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,eAAA,GAAA,qBAAA,GAAA,gBAAA;mCAyBzB,QAAA,EACF,UAAA,QAAkB,IAAA,CAAK,SAAA,MAAa,KAAA,aACjC,MAAA,CAAA,MAAA,SAAA,gBAAA;kDAAA,qBAAA,CAAA,UAAA;;8BAyBU,IAAA,gBAAoB,MAAA,CAAA,MAAA,UAAA,oBAAA;+BAUlB,GAAA,cAAc,MAAA,CAAA,MAAA,MAAA,gBAAA,GAAA,iBAAA;gCAgBb,GAAA,cAAc,IAAA,gBAAoB,MAAA,CAAA,MAAA,MAAA,iBAAA;oCAY9B,IAAA,aAAc,MAAA,CAAA,MAAA,KAAA,IAAA,yBA9Hf,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,cAAA,GAAA,mBAAA;qCA6IE,IAAA,aAAc,IAAA,gBAAoB,MAAA,CAAA,MAAA,UAAA,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,cAAA,GAAA,mBAAA;AAAA"}
+{"version":3,"file":"object.d.mts","names":[],"sources":["../../src/modules/object.ts"],"mappings":";;;;cAAsD,qBAAA;;;cAEhD,gBAAA,SAAyB,qBAAA;AAAA,cAG9B,qBAAA;;;cAEK,gBAAA,SAAyB,qBAAA;AAAA,cAG9B,sBAAA;;;;cAEK,iBAAA,SAA0B,sBAAA;AAAA,cAG/B,yBAAA;;;cAEK,oBAAA,SAA6B,yBAAA;AAAA,cAGlC,uBAAA;;;;;cAEK,kBAAA,SAA2B,uBAAA;AAAA,cAOhC,mBAAA;;;cAEK,cAAA,SAAuB,mBAAA;AAAA,cAG5B,wBAAA;;;;;cAEK,mBAAA,SAA4B,wBAAA;AAAA,cAOjC,0BAAA;;;;cAEK,qBAAA,SAA8B,0BAAA;AAAA,cAMnC,oBAAA;;;cAEK,eAAA,SAAwB,oBAAA;AAAA,cAG7B,qBAAA;;;cAEK,gBAAA,SAAyB,qBAAA;AAAA,cAmGlB,MAAA;;sBAGO,GAAA,aAAa,MAAA,CAAA,MAAA,UAAA,gBAAA;6BAQN,IAAA,aAAc,MAAA,CAAA,MAAA,UAAA,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,eAAA,GAAA,qBAAA,GAAA,gBAAA;mCAyBzB,QAAA,EACF,UAAA,QAAkB,IAAA,CAAK,SAAA,MAAa,KAAA,aACjC,MAAA,CAAA,MAAA,SAAA,gBAAA;;;8BAqBU,IAAA,gBAAoB,MAAA,CAAA,MAAA,UAAA,oBAAA;+BAUlB,GAAA,cAAc,MAAA,CAAA,MAAA,MAAA,gBAAA,GAAA,iBAAA;gCAgBb,GAAA,cAAc,IAAA,gBAAoB,MAAA,CAAA,MAAA,MAAA,iBAAA;oCAY9B,IAAA,aAAc,MAAA,CAAA,MAAA,KAAA,IAAA,yBA1Hf,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,cAAA,GAAA,mBAAA;qCAyIE,IAAA,aAAc,IAAA,gBAAoB,MAAA,CAAA,MAAA,UAAA,gBAAA,GAAA,gBAAA,GAAA,kBAAA,GAAA,cAAA,GAAA,mBAAA;AAAA"}

package/dist/modules/object.mjs

@@ -1,29 +1,29 @@
 import { Effect, Record, Schema, flow } from "effect";
 //#region src/modules/object.ts
-var NotAnObjectError = class extends Schema.TaggedError("NotAnObjectError")("NotAnObjectError", { actual: Schema.Unknown }) {};
-var KeyNotFoundError = class extends Schema.TaggedError("KeyNotFoundError")("KeyNotFoundError", { key: Schema.String }) {};
-var NotAFunctionError = class extends Schema.TaggedError("NotAFunctionError")("NotAFunctionError", {
+var NotAnObjectError = class extends Schema.TaggedError()("NotAnObjectError", { actual: Schema.Unknown }) {};
+var KeyNotFoundError = class extends Schema.TaggedError()("KeyNotFoundError", { key: Schema.String }) {};
+var NotAFunctionError = class extends Schema.TaggedError()("NotAFunctionError", {
 	key: Schema.String,
 	actual: Schema.Unknown
 }) {};
-var NotAConstructorError = class extends Schema.TaggedError("NotAConstructorError")("NotAConstructorError", { actual: Schema.Unknown }) {};
-var PathTraversalError = class extends Schema.TaggedError("PathTraversalError")("PathTraversalError", {
+var NotAConstructorError = class extends Schema.TaggedError()("NotAConstructorError", { actual: Schema.Unknown }) {};
+var PathTraversalError = class extends Schema.TaggedError()("PathTraversalError", {
 	path: Schema.String,
 	key: Schema.String,
 	current: Schema.Unknown
 }) {};
-var EmptyPathError = class extends Schema.TaggedError("EmptyPathError")("EmptyPathError", { path: Schema.String }) {};
-var MethodNotFoundError = class extends Schema.TaggedError("MethodNotFoundError")("MethodNotFoundError", {
+var EmptyPathError = class extends Schema.TaggedError()("EmptyPathError", { path: Schema.String }) {};
+var MethodNotFoundError = class extends Schema.TaggedError()("MethodNotFoundError", {
 	path: Schema.String,
 	methodKey: Schema.String,
 	actual: Schema.Unknown
 }) {};
-var IndexOutOfBoundsError = class extends Schema.TaggedError("IndexOutOfBoundsError")("IndexOutOfBoundsError", {
+var IndexOutOfBoundsError = class extends Schema.TaggedError()("IndexOutOfBoundsError", {
 	index: Schema.Number,
 	length: Schema.Number
 }) {};
-var NotAnArrayError = class extends Schema.TaggedError("NotAnArrayError")("NotAnArrayError", { actual: Schema.Unknown }) {};
-var InvalidPathError = class extends Schema.TaggedError("InvalidPathError")("InvalidPathError", { path: Schema.Unknown }) {};
+var NotAnArrayError = class extends Schema.TaggedError()("NotAnArrayError", { actual: Schema.Unknown }) {};
+var InvalidPathError = class extends Schema.TaggedError()("InvalidPathError", { path: Schema.Unknown }) {};
 const NUMERIC_KEY_REGEX = /^\d+$/;
 const isNumericKey = (key) => NUMERIC_KEY_REGEX.test(key);
 const getValueAtKey = (current, key) => {
@@ -104,14 +104,8 @@ const module = {
 		if (typeof obj !== "object" || obj === null) return yield* new NotAnObjectError({ actual: obj });
 		return JSON.stringify(obj, replacer, space);
 	}),
-	keys: flow((obj) => obj, Schema.decodeUnknown(Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	})), Effect.map(Record.keys)),
-	values: flow((obj) => obj, Schema.decodeUnknown(Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	})), Effect.map(Record.values)),
+	keys: flow((obj) => obj, Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown)), Effect.map(Record.keys)),
+	values: flow((obj) => obj, Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown)), Effect.map(Record.values)),
 	"new": (classRef, ...args) => Effect.gen(function* () {
 		if (typeof classRef !== "function") return yield* new NotAConstructorError({ actual: classRef });
 		return new classRef(...args);