effect-app 4.0.0-beta.0 → 4.0.0-beta.10

package/src/Schema/brand.ts

@@ -2,7 +2,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 import type { Option } from "effect"
 import * as B from "effect/Brand"
-import type * as Brand from "effect/Brand"
 import type * as Result from "effect/Result"
 import * as S from "effect/Schema"
 
@@ -21,7 +20,7 @@ export interface Constructor<in out A extends B.Brand<any>> {
    * Constructs a branded type from a value of type `A`, returning `Result.succeed`
    * if the provided `A` is valid, `Result.fail` otherwise.
    */
-  result(args: Unbranded<A>): Result.Result<A, Brand.BrandError>
+  result(args: Unbranded<A>): Result.Result<A, B.BrandError>
   /**
    * Attempts to refine the provided value of type `A`, returning `true` if
    * the provided `A` is valid, `false` otherwise.
@@ -29,19 +28,19 @@ export interface Constructor<in out A extends B.Brand<any>> {
   is(a: Unbranded<A>): a is Unbranded<A> & A
 }
 
-export const fromBrand = <C extends Brand.Brand<string>>(
+export const fromBrand = <C extends B.Brand<string>>(
   constructor: Constructor<C>,
   options?: S.Annotations.Filter
 ) =>
-<Self extends S.Top>(self: Self): S.brand<Self["~rebuild.out"], Brand.Brand.Keys<C>> => {
+<Self extends S.Top>(self: Self): S.brand<Self["~rebuild.out"], B.Brand.Keys<C>> => {
   const branded = S.fromBrand(options?.identifier ?? "Brand", constructor as any)(self as any)
   return options ? (branded as any).pipe(S.annotate(options)) : branded as any
 }
 
-export type Brands<P> = P extends B.Brand<any> ? Brand.Brand.Brands<P>
+export type Brands<P> = P extends B.Brand<any> ? B.Brand.Brands<P>
   : never
 
-export type Unbranded<P> = P extends B.Brand<any> ? Brand.Brand.Unbranded<P> : P
+export type Unbranded<P> = P extends B.Brand<any> ? B.Brand.Unbranded<P> : P
 
 export const nominal: <A extends B.Brand<any>>() => Constructor<A> = <
   A extends B.Brand<any>

package/src/Schema/moreStrings.ts

@@ -140,11 +140,10 @@ const minLength = 6
 const maxLength = 50
 const size = 21
 const length = 10 * size
-const StringIdArb = (): any => (fc: any) =>
+const StringIdArb = (): S.LazyArbitrary<string> => (fc) =>
   fc
     .uint8Array({ minLength: length, maxLength: length })
-    .map((_: any) => customRandom(urlAlphabet, size, (size: number) => _.subarray(0, size))())
-
+    .map((_) => customRandom(urlAlphabet, size, (size) => _.subarray(0, size))())
 /**
  * A string that is at least 6 characters long and a maximum of 50.
  */
@@ -178,12 +177,12 @@ export function prefixedStringId<Brand extends StringId>() {
   ) => {
     type FullPrefix = `${Prefix}${Separator}`
     const pref = `${prefix}${separator ?? "-"}` as FullPrefix
-    const arb = (): any => (fc: any) =>
+    const arb = (): S.LazyArbitrary<string & Brand> => (fc) =>
       StringIdArb()(fc).map(
-        (x: any) => (pref + x.substring(0, 50 - pref.length)) as Brand
+        (x) => (pref + x.substring(0, 50 - pref.length)) as Brand
       )
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const s: S.Schema<string & Brand> = StringId
+    const s: S.Codec<string & Brand, string> = StringId
       .pipe(
         S.refine((x: string): x is string & Brand => x.startsWith(pref), {
           arbitrary: arb,
@@ -217,10 +216,10 @@ export const brandedStringId = <
   Brand extends StringIdBrand
 >() =>
   withDefaultMake(
-    Object.assign(Object.create(StringId), StringId) as S.Schema<string & Brand> & {
+    Object.assign(Object.create(StringId), StringId) as S.Codec<string & Brand, string> & {
       make: () => string & Brand
-      withDefault: any
-    } & WithDefaults<S.Schema<string & Brand>>
+      withDefault: S.withConstructorDefault<S.Codec<string & Brand, string> & S.WithoutConstructorDefault>
+    } & WithDefaults<S.Codec<string & Brand, string>>
   )
 
 export interface PrefixedStringUtils<
@@ -232,7 +231,7 @@ export interface PrefixedStringUtils<
   readonly unsafeFrom: (str: string) => Brand
   prefixSafe: <REST extends string>(str: `${Prefix}${Separator}${REST}`) => Brand
   readonly prefix: Prefix
-  readonly withDefault: any
+  readonly withDefault: S.withConstructorDefault<S.Codec<Brand, string> & S.WithoutConstructorDefault>
 }
 
 export interface UrlBrand extends Simplify<B.Brand<"Url"> & NonEmptyStringBrand> {}
@@ -247,7 +246,7 @@ export const Url = S
   .String
   .pipe(
     S.refine(isUrl, {
-      arbitrary: (): any => (fc: any) => fc.webUrl().map((_: any) => _ as Url),
+      arbitrary: (): S.LazyArbitrary<Url> => (fc) => fc.webUrl().map((_) => _ as Url),
       identifier: "Url",
       title: "Url",
       jsonSchema: { format: "uri" }

package/src/Schema.ts

@@ -61,8 +61,8 @@ export const PhoneNumber = PhoneNumberT
     withDefaultMake
   )
 
-export const makeIs = <A extends { _tag: string }>(
-  schema: S.Schema<A>
+export const makeIs = <A extends { _tag: string }, I, R>(
+  schema: S.Codec<A, I, R>
 ) => {
   // In v4, transformations are stored as encoding on nodes, not as wrapper nodes.
   // Union member ASTs are directly Objects (TypeLiteral equivalent).
@@ -89,8 +89,8 @@ export const makeIs = <A extends { _tag: string }>(
   throw new Error("Unsupported")
 }
 
-export const makeIsAnyOf = <A extends { _tag: string }>(
-  schema: S.Schema<A>
+export const makeIsAnyOf = <A extends { _tag: string }, I, R>(
+  schema: S.Codec<A, I, R>
 ): IsAny<A> => {
   if (SchemaAST.isUnion(schema.ast)) {
     return <Keys extends A["_tag"][]>(...keys: Keys) => (a: A): a is ExtractUnion<A, ElemType<Keys>> =>
@@ -116,7 +116,7 @@ export const taggedUnionMap = <
     // TODO: v4 migration — PropertySignatureDeclaration removed, need v4 AST traversal
     const ast = key.fields._tag.ast as any
     const tag = ((ast.type ?? ast) as SchemaAST.Literal).literal as string // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-    ;(acc as any)[tag] = key as any
+    acc[tag] = key as any
     return acc
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   }, {} as any)
@@ -135,8 +135,8 @@ export const tags = <
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   })) as any
 
-export const ExtendTaggedUnion = <A extends { _tag: string }>(
-  schema: S.Schema<A>
+export const ExtendTaggedUnion = <A extends { _tag: string }, I, R>(
+  schema: S.Codec<A, I, R>
 ) =>
   extendM(
     schema,

package/src/ServiceMap.ts

@@ -7,13 +7,15 @@
 
 import { type Effect, Layer, type Scope, type Types } from "effect"
 import * as ServiceMap from "effect/ServiceMap"
-import { Yieldable } from "./Effect.js"
+import { type Yieldable } from "./Effect.js"
 
 export * from "effect/ServiceMap"
 
-export interface Opaque<Self extends object, in out Shape extends object> extends ServiceMap.Key<Self, Self>, Yieldable<Opaque<Self, Shape>, Self, never, Self> {
+export interface Opaque<Self extends object, in out Shape extends object>
+  extends ServiceMap.Key<Self, Self>, Yieldable<Opaque<Self, Shape>, Self, never, Self>
+{
   // temp while sorting out https://github.com/Effect-TS/effect-smol/pull/1534
-  of(self: Shape): Self
+  of(this: void, self: Shape): Self
   serviceMap(self: Shape): ServiceMap.ServiceMap<Self>
   // a version that leverages the Shape -> Self conversion
   toLayer: <E, R>(
@@ -151,7 +153,7 @@ export const Opaque: {
     id: Identifier,
     options?: {
       readonly make: ((...args: Args) => Effect.Effect<Shape, E, R>) | Effect.Effect<Shape, E, R> | undefined
-    } | undefined
+    }
   ) =>
     & OpaqueClass<Self, Identifier, Shape>
     & ([Types.unassigned] extends [R] ? unknown
@@ -181,7 +183,7 @@ export const Opaque: {
   const svc = ServiceMap.Service()(id, options) as any
   return Object.assign(svc, {
     toLayer: (eff: Effect.Effect<any, any, any>) => {
-      return Layer.effect(svc as any, eff)
+      return Layer.effect(svc, eff)
     }
   })
 }

package/src/client/apiClientFactory.ts

@@ -50,17 +50,17 @@ export const HttpClientLayer = (config: ApiConfig) =>
     Effect
       .gen(function*() {
         const baseClient = yield* HttpClient.HttpClient
-        const ctx = yield* RequestName
         const client = baseClient.pipe(
           HttpClient.mapRequest(HttpClientRequest.prependUrl(config.url + "/rpc")),
           HttpClient.mapRequest(
             HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => ({}))))
           ),
-          HttpClient.mapRequest((req) =>
-            flow(
-              HttpClientRequest.appendUrlParam("action", ctx.requestName),
-              HttpClientRequest.appendUrl("/" + ctx.moduleName)
-            )(req)
+          HttpClient.mapRequestEffect((req) =>
+            Effect.map(RequestName.asEffect(), (ctx) =>
+              flow(
+                HttpClientRequest.appendUrlParam("action", ctx.requestName),
+                HttpClientRequest.appendUrl("/" + ctx.moduleName)
+              )(req))
           )
         )
         return client
@@ -76,7 +76,7 @@ export const HttpClientFromConfigLayer = Layer.unwrap(
 
 export const RpcSerializationLayer = (config: ApiConfig) =>
   Layer.mergeAll(
-    RpcSerialization.layerJson,
+    RpcSerialization.layerNdjson,
     HttpClientLayer(config)
   )
 
@@ -91,7 +91,7 @@ const getFiltered = <M extends Requests>(resource: M) => {
   // TODO: Record.filter
   const filtered = typedKeysOf(resource).reduce((acc, cur) => {
     if (
-      Predicate.isObject(resource[cur])
+      Predicate.isObjectKeyword(resource[cur])
       && (resource[cur].success)
     ) {
       acc[cur as keyof Filtered] = resource[cur] as any
@@ -146,10 +146,7 @@ const makeRpcTag = <M extends Requests>(resource: M) => {
   // Use Layer.effect directly (not TheClient.toLayer) so TypeScript properly excludes Scope
   const layer = Layer.effect(
     TheClient,
-    Effect.map(
-      RpcClient.make(rpcs, { spanPrefix: "RpcClient." + meta.moduleName }),
-      (cl) => (cl as any)[meta.moduleName]
-    )
+    RpcClient.make(rpcs, { spanPrefix: "RpcClient." + meta.moduleName })
   )
   return Object.assign(TheClient, { layer })
 }
@@ -188,7 +185,7 @@ const makeApiClientFactory = Effect
         const filtered = getFiltered(resource)
         return {
           mr,
-          client: (typedKeysOf(filtered)
+          client: typedKeysOf(filtered)
             .reduce((prev, cur) => {
               const h = filtered[cur]!
 
@@ -211,7 +208,7 @@ const makeApiClientFactory = Effect
               const layers = requestLevelLayers.pipe(Layer.provideMerge(requestNameLayer))
 
               const fields = Struct.omit(Request.fields, ["_tag"] as const)
-              const requestAttr = h._tag
+              const requestAttr = `${meta.moduleName}.${h._tag}`
               // @ts-expect-error doc
               prev[cur] = Object.keys(fields).length === 0
                 ? {
@@ -246,7 +243,7 @@ const makeApiClientFactory = Effect
                 }
 
               return prev
-            }, {} as Client<M, M["meta"]["moduleName"]>))
+            }, {} as Client<M, M["meta"]["moduleName"]>)
         }
       })
 

package/src/client/clientFor.ts

@@ -58,11 +58,11 @@ export type Client<M extends RequestsAny, ModuleName extends string> = RequestHa
   ModuleName
 >
 
-export type ExtractResponse<T> = T extends S.Schema<any> ? S.Schema.Type<T>
+export type ExtractResponse<T> = T extends S.Codec<any> ? S.Schema.Type<T>
   : T extends unknown ? void
   : never
 
-export type ExtractEResponse<T> = T extends S.Schema<any> ? S.Codec.Encoded<T>
+export type ExtractEResponse<T> = T extends S.Codec<any> ? S.Codec.Encoded<T>
   : T extends unknown ? void
   : never
 

package/src/client/errors.ts

@@ -43,7 +43,10 @@ export class InvalidStateError extends TaggedError<InvalidStateError>()("Invalid
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any, disableValidation as any)
+    super(
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any,
+      disableValidation as any
+    )
   }
 }
 
@@ -51,7 +54,10 @@ export class ServiceUnavailableError extends TaggedError<ServiceUnavailableError
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any, disableValidation as any)
+    super(
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any,
+      disableValidation as any
+    )
   }
 }
 
@@ -116,7 +122,10 @@ export class OptimisticConcurrencyException extends TaggedError<OptimisticConcur
       | ({ message: string; cause?: unknown; raw?: unknown }),
     disableValidation?: boolean
   ) {
-    super("message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` } as any, disableValidation as any)
+    super(
+      "message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` } as any,
+      disableValidation as any
+    )
     if (!("message" in args)) {
       this.details = args
     }

package/src/client/makeClient.ts

@@ -1,4 +1,4 @@
-import { type GetContextConfig, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
+import { type GetContextConfig, type GetEffectError, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
 import * as S from "../Schema.js"
 import { AST } from "../Schema.js"
 
@@ -8,7 +8,7 @@ const merge = (a: any, b: Array<any>) =>
 /**
  * Whatever the input, we will only decode or encode to void
  */
-const ForceVoid: S.Schema<void> = S.Void as any
+const ForceVoid: S.Codec<void> = S.Void as any
 
 type SchemaOrFields<T> = T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void
 
@@ -44,8 +44,8 @@ export const makeRpcClient = <
 
   type MergeError<E> = [GeneralErrors] extends [never] ? SchemaOrFields<E> : S.Union<[SchemaOrFields<E>, GeneralErrors]>
   type ErrorResult<C> = C extends { error: infer E } ? MergeError<E>
-    : [GeneralErrors] extends [never] ? S.Void
-    : GeneralErrors
+    : [GeneralErrors] extends [never] ? GetEffectError<RequestContextMap["config"], C>
+    : MergeError<GetEffectError<RequestContextMap["config"], C>>
 
   function TaggedRequest<_Self>(): {
     <Tag extends string, Payload extends S.Struct.Fields, C extends ServiceMap>(
@@ -62,16 +62,16 @@ export const makeRpcClient = <
       tag: Tag,
       fields: Payload,
       config: RequestConfig & C
-    ): TaggedRequestResult<Tag, Payload, S.Schema<void>, ErrorResult<C>, Omit<C, "success" | "error">>
+    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<C>, Omit<C, "success" | "error">>
     <Tag extends string, Payload extends S.Struct.Fields, C extends Record<string, any>>(
       tag: Tag,
       fields: Payload,
       config: C & RequestConfig
-    ): TaggedRequestResult<Tag, Payload, S.Schema<void>, ErrorResult<C>, Omit<C, "success" | "error">>
+    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<C>, Omit<C, "success" | "error">>
     <Tag extends string, Payload extends S.Struct.Fields>(
       tag: Tag,
       fields: Payload
-    ): TaggedRequestResult<Tag, Payload, S.Schema<void>, ErrorResult<never>, Record<string, never>>
+    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<never>, Record<string, never>>
   } {
     // TODO: filter errors based on config + take care of inversion
     const errorSchemas = Object.values(rcs.config).map((_) => _.error)
@@ -92,22 +92,9 @@ export const makeRpcClient = <
           : S.Struct(config.success)
         : ForceVoid
 
-      const payloadSchema = S.Struct({ _tag: S.tag(tag), ...fields })
-
-      const taggedFields = { _tag: S.tag(tag), ...fields }
-
-      const RequestClass = class {
-        constructor(payload?: any) {
-          if (payload) {
-            Object.assign(this, payload)
-          }
-          ;(this as any)._tag = tag
-        }
-      }
-
-      Object.assign(RequestClass, payloadSchema, {
+      const RequestClass = S.TaggedClass<any>()(tag, fields)
+      Object.assign(RequestClass, {
         _tag: tag,
-        fields: taggedFields,
         success: successSchema,
         error: failureSchema,
         config

package/src/ids.ts

@@ -1,4 +1,4 @@
-import { brandedStringId, NonEmptyString255, type Schema, StringId, type StringIdBrand, withDefaultMake } from "effect-app/Schema"
+import { brandedStringId, type Codec, NonEmptyString255, StringId, type StringIdBrand, withDefaultMake } from "effect-app/Schema"
 import type { B } from "effect-app/Schema/schema"
 import type { Simplify } from "effect/Types"
 import { S } from "./index.js"
@@ -12,7 +12,7 @@ export type RequestId = NonEmptyString255
 // a request id may be made from a span id, which does not comply with StringId schema.
 export const RequestId = extendM(
   Object
-    .assign(Object.create(NonEmptyString255) as {}, NonEmptyString255 as unknown as Schema<NonEmptyString255>),
+    .assign(Object.create(NonEmptyString255) as {}, NonEmptyString255 as unknown as Codec<NonEmptyString255, string>),
   (s) => {
     const make = StringId.make as () => NonEmptyString255
     return ({

package/src/rpc/MiddlewareMaker.ts

@@ -14,7 +14,8 @@ import { type AddMiddleware, type AnyDynamic, type RpcDynamic, type RpcMiddlewar
 import * as RpcMiddlewareX from "./RpcMiddleware.js"
 
 // adapter for effect/rpc v3 middleware provides. (in effect-smol (v4), it's just a Service Identifier, no tags.)
-type MakeTags<A> = ServiceMap.Service<A, A>
+// hm?
+type MakeTags<A> = A
 
 export interface MiddlewareMaker<
   Self,
@@ -39,7 +40,7 @@ export interface MiddlewareMaker<
       })
       & (MiddlewareMaker.ManyErrors<MiddlewareProviders> extends never ? {}
         : {
-          readonly error: S.Schema<MiddlewareMaker.ManyErrors<MiddlewareProviders>>
+          readonly error: S.Codec<MiddlewareMaker.ManyErrors<MiddlewareProviders>>
         })
       & (MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? {}
         : { readonly provides: MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>> })
@@ -332,7 +333,7 @@ const makeMiddlewareBasic = <Self>() =>
     error: (firstFailure
       ? S.Union([firstFailure, ...restFailures])
       : S.Never) as unknown as MiddlewareMaker.ManyErrors<MiddlewareProviders> extends never ? never
-        : S.Schema<MiddlewareMaker.ManyErrors<MiddlewareProviders>>,
+        : S.Codec<MiddlewareMaker.ManyErrors<MiddlewareProviders>>,
     requires: (requires.length > 0
       ? requires
       : undefined) as unknown as Exclude<

package/src/rpc/RpcMiddleware.ts

@@ -59,7 +59,7 @@ export declare namespace TagClass {
    * @since 1.0.0
    * @category models
    */
-  export type Failure<Options> = Options extends { readonly error: Schema.Schema<infer _A>; readonly optional?: false }
+  export type Failure<Options> = Options extends { readonly error: Schema.Codec<infer _A>; readonly optional?: false }
     ? _A
     // actually not, the Failure depends on Dynamic Middleware Configuration!
     : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? S.Schema.Type<A["error"]>
@@ -226,8 +226,8 @@ export type ExtractProvides<R extends Rpc.Any, Tag extends string> = R extends
   Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware, infer _Requires> ? _Middleware extends {
     readonly provides: infer _P
   } ? [_P] extends [never] ? never
-    : _P extends ServiceMap.Service<infer _I, infer _S> ? _I
-    : never
+    : _P /*_P extends ServiceMap.Service<infer _I, infer _S> ? _I
+    : never */
   : never
   : never
 

package/src/utils.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-redundant-type-constituents */
-import { Effect, Exit, Fiber, Option, Record } from "effect"
+import { Cause, Effect, Exit, Fiber, Option, Record } from "effect"
 import { dual } from "effect/Function"
 import { isFunction } from "effect/Predicate"
 import * as Result from "effect/Result"
@@ -924,8 +924,7 @@ export const runtimeFiberAsPromise = <A, E>(fiber: Fiber.Fiber<A, E>, signal?: A
       if (Exit.isSuccess(exit)) {
         resolve(exit.value)
       } else {
-        // errors really should be of type Error, so we wrap in FiberFailure just as default Effect
-        reject(exit.cause)
+        reject(Cause.squash(exit.cause))
       }
     })
   )

package/test/dist/rpc.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}