@soundscript/cli-linux-x64 0.1.1 → 0.1.3

package/src/stdlib/async.d.ts

@@ -54,15 +54,15 @@ export function flatMap<A, B, E1, E2>(
 ): Task<B, E1 | E2>;
 export function recover<A, B, E>(
   task: Task<A, E>,
-  project: (error: E) => B | PromiseLike<B>,
+  project: (error: E) => B | Promise<B>,
 ): Task<A | B, Error>;
 export function tap<A, E>(
   task: Task<A, E>,
-  effect: (value: A) => unknown | PromiseLike<unknown>,
+  effect: (value: A) => unknown | Promise<unknown>,
 ): Task<A, E | Error>;
 export function tapError<A, E>(
   task: Task<A, E>,
-  effect: (error: E) => unknown | PromiseLike<unknown>,
+  effect: (error: E) => unknown | Promise<unknown>,
 ): Task<A, E | Error>;
 export function parallel<T, E>(tasks: readonly Task<T, E>[]): Task<readonly T[], E>;
 export function race<T, E>(

package/src/stdlib/codec.d.ts

@@ -6,8 +6,9 @@ import type { Invariant } from 'sts:typeclasses';
 export { booleanEncoder, contramap, numberEncoder, stringEncoder } from 'sts:encode';
 export type { EncodeFailure, Encoder } from 'sts:encode';
 
-export interface Codec<T, TEncoded = unknown, DE = DecodeFailure, EE = EncodeFailure>
-  extends Decoder<T, DE>, Encoder<T, TEncoded, EE> {}
+// #[variance(T: inout, TEncoded: out, DE: out, EE: out)]
+export type Codec<T, TEncoded = unknown, DE = DecodeFailure, EE = EncodeFailure> =
+  Decoder<T, DE> & Encoder<T, TEncoded, EE>;
 
 export interface CodecF extends TypeLambda {
   readonly type: Codec<this['Args'][3], this['Args'][2], this['Args'][1], this['Args'][0]>;

package/src/stdlib/decode.d.ts

@@ -17,14 +17,16 @@ export class DecodeFailure extends Failure {
   at(segment: DecodePathSegment): this;
 }
 
-export interface Decoder<T, E = DecodeFailure> {
+// #[variance(T: out, E: out)]
+export type Decoder<T, E = DecodeFailure> = {
   decode(value: unknown): Result<T, E>;
-}
+};
 
-export interface OptionalDecoder<T, E = DecodeFailure> extends Decoder<T | undefined, E> {
+// #[variance(T: out, E: out)]
+export type OptionalDecoder<T, E = DecodeFailure> = Decoder<T | undefined, E> & {
   readonly __soundscriptOptional: true;
   readonly inner: Decoder<T, E>;
-}
+};
 
 type DecoderValue<TDecoder> = TDecoder extends Decoder<infer TValue, unknown> ? TValue : never;
 type DecoderError<TDecoder> = TDecoder extends Decoder<unknown, infer E> ? E : never;

package/src/stdlib/encode.d.ts

@@ -7,15 +7,17 @@ export class EncodeFailure extends Failure {
   constructor(message?: string, cause?: unknown);
 }
 
-export interface Encoder<T, TEncoded = unknown, E = EncodeFailure> {
+// #[variance(T: in, TEncoded: out, E: out)]
+export type Encoder<T, TEncoded = unknown, E = EncodeFailure> = {
   encode(value: T): Result<TEncoded, E>;
-}
+};
 
-export interface OptionalEncoder<T, TEncoded = T, E = EncodeFailure>
-  extends Encoder<T | undefined, TEncoded | undefined, E> {
-  readonly __soundscriptOptional: true;
-  readonly inner: Encoder<T, TEncoded, E>;
-}
+// #[variance(T: in, TEncoded: out, E: out)]
+export type OptionalEncoder<T, TEncoded = T, E = EncodeFailure> =
+  Encoder<T | undefined, TEncoded | undefined, E> & {
+    readonly __soundscriptOptional: true;
+    readonly inner: Encoder<T, TEncoded, E>;
+  };
 
 type EncoderInput<TEncoder> = TEncoder extends Encoder<infer TValue, unknown, unknown> ? TValue
   : never;
@@ -72,8 +74,8 @@ export function option<T, TEncoded, E>(
   item: Encoder<T, TEncoded, E>,
 ): Encoder<
   Option<T>,
-  { readonly error?: undefined; readonly tag: 'err' } | {
-    readonly tag: 'ok';
+  { readonly tag: 'none' } | {
+    readonly tag: 'some';
     readonly value: TEncoded;
   },
   E

package/src/stdlib/fetch.d.ts

@@ -0,0 +1,67 @@
+import { URL, URLSearchParams } from 'sts:url';
+
+export interface AbortSignal {
+  readonly aborted: boolean;
+  readonly reason: unknown;
+  throwIfAborted(): void;
+}
+
+export type HeadersInit = Headers | Iterable<readonly [string, string]> | Record<string, string>;
+export type BodyInit = ArrayBuffer | string | Uint8Array<ArrayBufferLike> | URLSearchParams;
+export type RequestInfo = Request | string | URL;
+
+export interface RequestInit {
+  readonly body?: BodyInit | null;
+  readonly headers?: HeadersInit;
+  readonly method?: string;
+  readonly signal?: AbortSignal | null;
+}
+
+export interface ResponseInit {
+  readonly headers?: HeadersInit;
+  readonly status?: number;
+  readonly statusText?: string;
+}
+
+export declare class Headers {
+  constructor(init?: HeadersInit);
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  entries(): IterableIterator<[string, string]>;
+  get(name: string): string | null;
+  has(name: string): boolean;
+  keys(): IterableIterator<string>;
+  set(name: string, value: string): void;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+
+export declare class Request {
+  constructor(input: RequestInfo, init?: RequestInit);
+  readonly headers: Headers;
+  readonly method: string;
+  readonly signal: AbortSignal;
+  readonly url: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  clone(): Request;
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+}
+
+export declare class Response {
+  constructor(body?: BodyInit | null, init?: ResponseInit);
+  readonly headers: Headers;
+  readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly url: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  clone(): Response;
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+  static error(): Response;
+  static json(data: unknown, init?: ResponseInit): Response;
+  static redirect(url: string | URL, status?: number): Response;
+}
+
+export declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;

package/src/stdlib/json.d.ts

@@ -2,6 +2,7 @@ import { Failure } from 'sts:failures';
 import type { Decoder } from 'sts:decode';
 import type { Encoder } from 'sts:encode';
 import type { Result } from 'sts:result';
+import type { Numeric } from 'sts:numerics';
 
 export type JsonArray = JsonValue[];
 export type JsonObject = {
@@ -35,15 +36,33 @@ export type JsonLikeValue =
   | JsonLikeObject
   | JsonLikeArray;
 
+export type MachineJsonArray = MachineJsonLikeValue[];
+export type MachineJsonObject = {
+  [key: string]: MachineJsonLikeValue;
+};
+export type MachineJsonLikeValue =
+  | string
+  | number
+  | boolean
+  | bigint
+  | null
+  | undefined
+  | Numeric
+  | MachineJsonObject
+  | MachineJsonArray;
+
 export interface JsonParseOptions {
   int64?: 'default' | 'lossless';
+  numerics?: 'tagged';
 }
 
 export type JsonStringifyBigintMode = 'number' | 'reject' | 'string';
+export type MachineJsonNumericMode = 'tagged' | 'decimal-string' | 'json-number';
 
 export interface JsonStringifyOptions {
   int64?: 'default' | 'string' | 'lossless';
   readonly bigint?: JsonStringifyBigintMode;
+  numerics?: MachineJsonNumericMode;
 }
 
 export class JsonParseFailure extends Failure {
@@ -59,17 +78,25 @@ export function parseJson(
   text: string,
   options: JsonParseOptions & { int64: 'lossless' },
 ): Result<LosslessJsonValue, JsonParseFailure>;
+export function parseJson(
+  text: string,
+  options: JsonParseOptions & { numerics: 'tagged' },
+): Result<MachineJsonLikeValue, JsonParseFailure>;
 export function parseJson(
   text: string,
   options?: JsonParseOptions,
-): Result<JsonValue | LosslessJsonValue, JsonParseFailure>;
+): Result<JsonValue | LosslessJsonValue | MachineJsonLikeValue, JsonParseFailure>;
 export function stringifyJson(value: JsonValue): Result<string, JsonStringifyFailure>;
 export function stringifyJson(
   value: LosslessJsonValue,
   options: JsonStringifyOptions & { int64: 'string' | 'lossless' },
 ): Result<string, JsonStringifyFailure>;
 export function stringifyJson(
-  value: JsonValue | LosslessJsonValue,
+  value: MachineJsonLikeValue,
+  options: JsonStringifyOptions & { numerics: MachineJsonNumericMode },
+): Result<string, JsonStringifyFailure>;
+export function stringifyJson(
+  value: JsonValue | LosslessJsonValue | MachineJsonLikeValue,
   options?: JsonStringifyOptions,
 ): Result<string, JsonStringifyFailure>;
 export function parseAndDecode<T, E>(