@soundscript/cli-darwin-arm64 0.1.2 → 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

@@ -1,4 +1,4 @@
-import { URL, URLSearchParams } from './url';
+import { URL, URLSearchParams } from 'sts:url';
 
 export interface AbortSignal {
   readonly aborted: boolean;

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>(