@soundscript/cli-linux-arm64 0.1.0

package/src/stdlib/async.d.ts

@@ -0,0 +1,81 @@
+import type { Bind, Kind2, TypeLambda } from 'sts:hkt';
+import { Failure } from 'sts:failures';
+import type { Result } from 'sts:result';
+import type { Applicative, AsyncMonad, Functor, Monad } from 'sts:typeclasses';
+
+export interface AbortSignalLike {
+  readonly aborted: boolean;
+  readonly reason?: unknown;
+  addEventListener(
+    type: 'abort',
+    listener: () => void,
+    options?: boolean | { once?: boolean },
+  ): void;
+  removeEventListener(type: 'abort', listener: () => void, options?: boolean): void;
+}
+
+export type Task<T, E = Error> = (signal?: AbortSignalLike) => Promise<Result<T, E>>;
+
+export interface TaskF extends TypeLambda {
+  readonly type: Task<this['Args'][1], this['Args'][0]>;
+}
+
+export interface PromiseF extends TypeLambda {
+  readonly type: Promise<this['Args'][0]>;
+}
+
+export type TaskKind<E, T> = Kind2<TaskF, E, T>;
+export type PromiseKind<T> = Promise<T>;
+
+export class TimeoutFailure extends Failure {
+  readonly ms: number;
+  constructor(ms: number, cause?: unknown);
+}
+
+export function succeed<T>(value: T): Task<T, never>;
+export function fail<E>(error: E): Task<never, E>;
+export function fromResult<T, E>(result: Result<T, E>): Task<T, E>;
+export function fromPromise<T>(fn: (signal?: AbortSignalLike) => Promise<T>): Task<T, Error>;
+export function fromPromise<T, E>(
+  fn: (signal?: AbortSignalLike) => Promise<T>,
+  mapError: (error: Error) => E,
+): Task<T, E>;
+export function map<A, B, E>(
+  task: Task<A, E>,
+  project: (value: A) => B,
+): Task<B, E>;
+export function mapError<A, E1, E2>(
+  task: Task<A, E1>,
+  project: (error: E1) => E2,
+): Task<A, E2 | Error>;
+export function flatMap<A, B, E1, E2>(
+  task: Task<A, E1>,
+  project: (value: A) => Task<B, E2>,
+): Task<B, E1 | E2>;
+export function recover<A, B, E>(
+  task: Task<A, E>,
+  project: (error: E) => B | PromiseLike<B>,
+): Task<A | B, Error>;
+export function tap<A, E>(
+  task: Task<A, E>,
+  effect: (value: A) => unknown | PromiseLike<unknown>,
+): Task<A, E | Error>;
+export function tapError<A, E>(
+  task: Task<A, E>,
+  effect: (error: E) => unknown | PromiseLike<unknown>,
+): Task<A, E | Error>;
+export function parallel<T, E>(tasks: readonly Task<T, E>[]): Task<readonly T[], E>;
+export function race<T, E>(
+  tasks: readonly [Task<T, E>, ...Task<T, E>[]],
+): Task<T, E>;
+export function timeout<T, E>(task: Task<T, E>, ms: number): Task<T, E | TimeoutFailure>;
+
+export function taskFunctor<E>(): Functor<Bind<TaskF, [E]>>;
+export function taskApplicative<E>(): Applicative<Bind<TaskF, [E]>>;
+export function taskMonad<E>(): Monad<Bind<TaskF, [E]>>;
+export function taskAsyncMonad<E>(): AsyncMonad<Bind<TaskF, [E]>>;
+
+export const promiseFunctor: Functor<PromiseF>;
+export const promiseApplicative: Applicative<PromiseF>;
+export const promiseMonad: Monad<PromiseF>;
+export const promiseAsyncMonad: AsyncMonad<PromiseF>;

package/src/stdlib/codec.d.ts

@@ -0,0 +1,31 @@
+import type { Bind, TypeLambda } from 'sts:hkt';
+import { type DecodeFailure, type Decoder } from 'sts:decode';
+import { contramap, type EncodeFailure, type Encoder } from 'sts:encode';
+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> {}
+
+export interface CodecF extends TypeLambda {
+  readonly type: Codec<this['Args'][3], this['Args'][2], this['Args'][1], this['Args'][0]>;
+}
+
+export function codec<T, TEncoded, DE, EE>(
+  decoder: Decoder<T, DE>,
+  encoder: Encoder<T, TEncoded, EE>,
+): Codec<T, TEncoded, DE, EE>;
+export function imap<A, B, TEncoded, DE, EE>(
+  base: Codec<A, TEncoded, DE, EE>,
+  decodeMap: (value: A) => B,
+  encodeMap: (value: B) => A,
+): Codec<B, TEncoded, DE, EE>;
+export function codecInvariant<TEncoded, DE = DecodeFailure, EE = EncodeFailure>(): Invariant<
+  Bind<Bind<Bind<CodecF, [EE]>, [DE]>, [TEncoded]>
+>;
+
+export const stringCodec: Codec<string, string>;
+export const numberCodec: Codec<number, number>;
+export const booleanCodec: Codec<boolean, boolean>;

package/src/stdlib/compare.d.ts

@@ -0,0 +1,28 @@
+import type { Option, Result } from 'sts:result';
+
+export type Ordering = -1 | 0 | 1;
+
+export interface Eq<T> {
+  equals(left: T, right: T): boolean;
+}
+
+export interface Order<T> extends Eq<T> {
+  compare(left: T, right: T): Ordering;
+}
+
+type EqValue<TEq> = TEq extends Eq<infer TValue> ? TValue : never;
+
+export const stringEq: Eq<string>;
+export const numberEq: Eq<number>;
+export const booleanEq: Eq<boolean>;
+export const bigintEq: Eq<bigint>;
+export function lazyEq<T>(getEq: () => Eq<T>): Eq<T>;
+export function arrayEq<T>(itemEq: Eq<T>): Eq<readonly T[]>;
+export function tupleEq<const TEqs extends readonly Eq<unknown>[]>(
+  ...elements: TEqs
+): Eq<{ readonly [K in keyof TEqs]: EqValue<TEqs[K]> }>;
+export function optionEq<T>(itemEq: Eq<T>): Eq<Option<T>>;
+export function resultEq<T, E>(okEq: Eq<T>, errEq: Eq<E>): Eq<Result<T, E>>;
+export function fromCompare<T>(compare: (left: T, right: T) => number): Order<T>;
+export function reverse<T>(order: Order<T>): Order<T>;
+export function thenBy<T>(primary: Order<T>, secondary: Order<T>): Order<T>;

package/src/stdlib/component.d.ts

@@ -0,0 +1,40 @@
+export interface ComponentContextKey<T> {
+  readonly __ss_component_context_key: symbol;
+  readonly __ss_component_context_type__?: (_value: T) => T;
+}
+
+export interface ComponentEvent<Detail = unknown, Target = unknown> {
+  readonly currentTarget: Target;
+  readonly detail: Detail;
+  readonly target: Target;
+  readonly type: string;
+}
+
+export function state<T>(value: T): T;
+export function awaited<T, PendingResult, FulfilledResult, RejectedResult = never>(
+  promise: PromiseLike<T>,
+  pending: PendingResult | (() => PendingResult),
+  fulfilled: (value: T) => FulfilledResult,
+  rejected?: (error: unknown) => RejectedResult,
+): PendingResult | FulfilledResult | RejectedResult;
+export function boundary<RenderResult, FallbackResult>(
+  render: () => RenderResult,
+  fallback: (error: unknown) => FallbackResult,
+): RenderResult | FallbackResult;
+export function context<T>(): ComponentContextKey<T>;
+export function dispatch<T = undefined>(type: string, detail?: T): void;
+export function derived<T>(compute: () => T): T;
+export function effect<T>(callback: () => T): T;
+export function onMount<T>(callback: () => T): T;
+export function prop<T = never>(): T;
+export function prop<T>(value: T): T;
+export function provide<T, R>(context: ComponentContextKey<T>, value: T, content: R): R;
+export function provide<T, R>(
+  context: ComponentContextKey<T>,
+  value: T,
+  content: () => R,
+): R;
+export function useContext<T>(value: ComponentContextKey<T>): T;
+export function useStore<T>(value: T): T;
+export function component<T>(value: T): T;
+export function store<T>(value: T): T;

package/src/stdlib/css.d.ts

@@ -0,0 +1,16 @@
+export interface CssRawFragment {
+  readonly __cssKind: 'raw';
+  readonly text: string;
+}
+
+export interface CssTemplate {
+  readonly text: string;
+  readonly values: readonly unknown[];
+}
+
+export interface CssTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): CssTemplate;
+  raw(text: string): CssRawFragment;
+}
+
+export const css: CssTag;

package/src/stdlib/debug.d.ts

@@ -0,0 +1,2 @@
+export function assert(condition: unknown, message?: string): asserts condition;
+export function log<T>(value: T): T;

package/src/stdlib/decode.d.ts

@@ -0,0 +1,84 @@
+import { type ErrorFrame, Failure } from 'sts:failures';
+import type { Option, Result } from 'sts:result';
+
+export type DecodePathSegment = string | number;
+export type DecodePath = readonly DecodePathSegment[];
+
+export class DecodeFailure extends Failure {
+  readonly path: DecodePath;
+  constructor(
+    message?: string,
+    options?: {
+      cause?: unknown;
+      path?: DecodePath;
+      trace?: readonly ErrorFrame[];
+    },
+  );
+  at(segment: DecodePathSegment): this;
+}
+
+export interface Decoder<T, E = DecodeFailure> {
+  decode(value: unknown): Result<T, E>;
+}
+
+export interface OptionalDecoder<T, E = DecodeFailure> extends 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;
+type ObjectShape = Record<string, Decoder<unknown, unknown>>;
+type TupleShape = readonly Decoder<unknown, unknown>[];
+
+export const string: Decoder<string>;
+export const number: Decoder<number>;
+export const boolean: Decoder<boolean>;
+export const bigint: Decoder<bigint>;
+export function lazy<T, E>(getDecoder: () => Decoder<T, E>): Decoder<T, E>;
+
+export function optional<T, E>(decoder: Decoder<T, E>): OptionalDecoder<T, E>;
+export function literal<const T extends string | number | boolean | null>(value: T): Decoder<T>;
+export function array<T, E>(item: Decoder<T, E>): Decoder<readonly T[], E | DecodeFailure>;
+export function tuple<const TElements extends TupleShape>(
+  ...elements: TElements
+): Decoder<
+  { readonly [K in keyof TElements]: DecoderValue<TElements[K]> },
+  DecoderError<TElements[number]> | DecodeFailure
+>;
+export function option<T, E>(item: Decoder<T, E>): Decoder<Option<T>, E | DecodeFailure>;
+export function result<T, EValue, EDecodeValue, EDecodeError>(
+  okDecoder: Decoder<T, EDecodeValue>,
+  errDecoder: Decoder<EValue, EDecodeError>,
+): Decoder<Result<T, EValue>, EDecodeValue | EDecodeError | DecodeFailure>;
+export function object<TShape extends ObjectShape>(
+  shape: TShape,
+): Decoder<
+  { readonly [K in keyof TShape]: DecoderValue<TShape[K]> },
+  DecoderError<TShape[keyof TShape]> | DecodeFailure
+>;
+export function field<K extends string, T, E>(
+  key: K,
+  decoder: Decoder<T, E>,
+): Decoder<T, E | DecodeFailure>;
+export function optionalField<K extends string, T, E>(
+  key: K,
+  decoder: Decoder<T, E>,
+): Decoder<T | undefined, E | DecodeFailure>;
+export function union<A, B, ELeft, ERight>(
+  left: Decoder<A, ELeft>,
+  right: Decoder<B, ERight>,
+): Decoder<A | B, ELeft | ERight | DecodeFailure>;
+export function map<A, B, E>(
+  decoder: Decoder<A, E>,
+  project: (value: A) => B,
+): Decoder<B, E>;
+export function andThen<A, B, E>(
+  decoder: Decoder<A, E>,
+  project: (value: A) => Decoder<B, E>,
+): Decoder<B, E>;
+export function refine<A, B extends A, E>(
+  decoder: Decoder<A, E>,
+  predicate: (value: A) => value is B,
+  message: string,
+): Decoder<B, E | DecodeFailure>;

package/src/stdlib/derive.d.ts

@@ -0,0 +1,6 @@
+export const eq: unknown;
+export const hash: unknown;
+export const decode: unknown;
+export const encode: unknown;
+export const codec: unknown;
+export const tagged: unknown;

package/src/stdlib/encode.d.ts

@@ -0,0 +1,98 @@
+import type { Bind, Kind3, TypeLambda } from 'sts:hkt';
+import { Failure } from 'sts:failures';
+import type { Option, Result } from 'sts:result';
+import type { Contravariant } from 'sts:typeclasses';
+
+export class EncodeFailure extends Failure {
+  constructor(message?: string, cause?: unknown);
+}
+
+export interface 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>;
+}
+
+type EncoderInput<TEncoder> = TEncoder extends Encoder<infer TValue, unknown, unknown> ? TValue
+  : never;
+type EncoderOutput<TEncoder> = TEncoder extends Encoder<unknown, infer TEncoded, unknown>
+  ? TEncoded
+  : never;
+type EncoderError<TEncoder> = TEncoder extends Encoder<unknown, unknown, infer E> ? E : never;
+type ObjectShape = Record<string, Encoder<unknown, unknown, unknown>>;
+type TupleShape = readonly Encoder<unknown, unknown, unknown>[];
+
+export interface EncoderF extends TypeLambda {
+  readonly type: Encoder<this['Args'][2], this['Args'][1], this['Args'][0]>;
+}
+
+export type EncoderKind<E, TEncoded, T> = Kind3<EncoderF, E, TEncoded, T>;
+
+export function fromEncode<T, TEncoded, E>(
+  encode: (value: T) => Result<TEncoded, E>,
+): Encoder<T, TEncoded, E>;
+export function contramap<A, B, TEncoded, E>(
+  encoder: Encoder<A, TEncoded, E>,
+  project: (value: B) => A,
+): Encoder<B, TEncoded, E>;
+export function encoderContravariant<TEncoded, E = EncodeFailure>(): Contravariant<
+  Bind<Bind<EncoderF, [E]>, [TEncoded]>
+>;
+
+export const stringEncoder: Encoder<string, string>;
+export const numberEncoder: Encoder<number, number>;
+export const booleanEncoder: Encoder<boolean, boolean>;
+export const bigintEncoder: Encoder<bigint, bigint>;
+
+export function optional<T, TEncoded, E>(
+  encoder: Encoder<T, TEncoded, E>,
+): OptionalEncoder<T, TEncoded, E>;
+export function lazy<T, TEncoded, E>(
+  getEncoder: () => Encoder<T, TEncoded, E>,
+): Encoder<T, TEncoded, E>;
+export function nullable<T, TEncoded, E>(
+  encoder: Encoder<T, TEncoded, E>,
+): Encoder<T | null, TEncoded | null, E>;
+export function literal<const T extends string | number | boolean | null>(value: T): Encoder<T, T>;
+export function array<T, TEncoded, E>(
+  item: Encoder<T, TEncoded, E>,
+): Encoder<readonly T[], readonly TEncoded[], E | EncodeFailure>;
+export function tuple<const TElements extends TupleShape>(
+  ...elements: TElements
+): Encoder<
+  { readonly [K in keyof TElements]: EncoderInput<TElements[K]> },
+  { readonly [K in keyof TElements]: EncoderOutput<TElements[K]> },
+  EncoderError<TElements[number]>
+>;
+export function option<T, TEncoded, E>(
+  item: Encoder<T, TEncoded, E>,
+): Encoder<
+  Option<T>,
+  { readonly error?: undefined; readonly tag: 'err' } | {
+    readonly tag: 'ok';
+    readonly value: TEncoded;
+  },
+  E
+>;
+export function result<T, EValue, TEncoded, EEncoded, EOk, EErr>(
+  okEncoder: Encoder<T, TEncoded, EOk>,
+  errEncoder: Encoder<EValue, EEncoded, EErr>,
+): Encoder<
+  Result<T, EValue>,
+  { readonly tag: 'ok'; readonly value: TEncoded } | {
+    readonly error: EEncoded;
+    readonly tag: 'err';
+  },
+  EOk | EErr
+>;
+export function object<TShape extends ObjectShape>(
+  shape: TShape,
+): Encoder<
+  { readonly [K in keyof TShape]: EncoderInput<TShape[K]> },
+  { readonly [K in keyof TShape]: EncoderOutput<TShape[K]> },
+  EncoderError<TShape[keyof TShape]> | EncodeFailure
+>;

package/src/stdlib/failures.d.ts

@@ -0,0 +1,23 @@
+export type ErrorFrame = {
+  readonly column: number;
+  readonly file: string;
+  readonly fn?: string;
+  readonly line: number;
+};
+
+export class Failure {
+  readonly cause?: unknown;
+  readonly message: string;
+  readonly name: string;
+  readonly trace: readonly ErrorFrame[];
+  constructor(
+    message?: string,
+    options?: {
+      cause?: unknown;
+      trace?: readonly ErrorFrame[];
+    },
+  );
+  withFrame(frame: ErrorFrame): this;
+}
+
+export function normalizeThrown(value: unknown): Error;

package/src/stdlib/graphql.d.ts

@@ -0,0 +1,16 @@
+export interface GraphqlRawFragment {
+  readonly __graphqlKind: 'raw';
+  readonly text: string;
+}
+
+export interface GraphqlQuery {
+  readonly query: string;
+  readonly values: readonly unknown[];
+}
+
+export interface GraphqlTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): GraphqlQuery;
+  raw(text: string): GraphqlRawFragment;
+}
+
+export const graphql: GraphqlTag;

package/src/stdlib/hash.d.ts

@@ -0,0 +1,34 @@
+import type { Eq } from 'sts:compare';
+import type { Option, Result } from 'sts:result';
+
+export type HashCode = number;
+
+export interface Hash<T> {
+  hash(value: T): HashCode;
+}
+
+export interface HashEq<T> extends Hash<T>, Eq<T> {}
+
+type HashEqValue<THashEq> = THashEq extends HashEq<infer TValue> ? TValue : never;
+
+export function fromHashEq<T>(
+  hash: (value: T) => HashCode,
+  equals: (left: T, right: T) => boolean,
+): HashEq<T>;
+export function contramap<A, B>(
+  hashEq: HashEq<A>,
+  project: (value: B) => A,
+): HashEq<B>;
+export function lazyHashEq<T>(getHashEq: () => HashEq<T>): HashEq<T>;
+export function arrayHash<T>(itemHash: HashEq<T>): HashEq<readonly T[]>;
+export function tupleHash<const THashEqs extends readonly HashEq<unknown>[]>(
+  ...elements: THashEqs
+): HashEq<{ readonly [K in keyof THashEqs]: HashEqValue<THashEqs[K]> }>;
+export function optionHash<T>(itemHash: HashEq<T>): HashEq<Option<T>>;
+export function resultHash<T, E>(okHash: HashEq<T>, errHash: HashEq<E>): HashEq<Result<T, E>>;
+
+export const stringHash: HashEq<string>;
+export const numberHash: HashEq<number>;
+export const booleanHash: HashEq<boolean>;
+export const bigintHash: HashEq<bigint>;
+export function combineHashes(...hashes: readonly HashCode[]): HashCode;

package/src/stdlib/hkt.d.ts

@@ -0,0 +1,40 @@
+export interface TypeLambda {
+  readonly Args: readonly unknown[];
+  readonly type: unknown;
+}
+
+export type Apply<F extends TypeLambda, Args extends readonly unknown[]> = F extends {
+  readonly __target: infer Target extends TypeLambda;
+  readonly __prefix: infer Prefix extends readonly unknown[];
+} ? Apply<Target, [...Prefix, ...Args]>
+  : (F & { readonly Args: Args })['type'];
+
+export type Bind<F extends TypeLambda, Prefix extends readonly unknown[]> = TypeLambda & {
+  readonly __target: F;
+  readonly __prefix: Prefix;
+};
+
+export type Kind<F extends TypeLambda, A> = Apply<F, [A]>;
+export type Kind2<F extends TypeLambda, A, B> = Apply<F, [A, B]>;
+export type Kind3<F extends TypeLambda, A, B, C> = Apply<F, [A, B, C]>;
+
+export type MonadTypeLambda<M extends { readonly __type_lambda?: TypeLambda }> = M extends {
+  readonly __type_lambda?: infer F extends TypeLambda;
+} ? F
+  : never;
+export type BoundEffect<F extends TypeLambda, A = unknown> = Kind<F, A>;
+export type BoundValue<F extends TypeLambda, Value> = Value extends BoundEffect<F, infer A> ? A
+  : never;
+export type Binder<F extends TypeLambda> = <A>(value: BoundEffect<F, A>) => A;
+
+export type {
+  Applicative,
+  AsyncMonad,
+  Contravariant,
+  Functor,
+  Invariant,
+  Monad,
+} from 'sts:typeclasses';
+export { Do, monadGen } from 'sts:typeclasses';
+
+export const hkt: unknown;

package/src/stdlib/index.d.ts

@@ -0,0 +1,9 @@
+export type { Err, None, Ok, Option, Result, Some } from 'sts:result';
+
+export { err, isErr, isNone, isOk, isSome, none, ok, some, Try } from 'sts:result';
+export { Match, where } from 'sts:match';
+export { Failure } from 'sts:failures';
+
+export function Defer(cleanup: () => unknown): never;
+export function todo(message?: string): never;
+export function unreachable(message?: string): never;

package/src/stdlib/json.d.ts

@@ -0,0 +1,98 @@
+import { Failure } from 'sts:failures';
+import type { Decoder } from 'sts:decode';
+import type { Encoder } from 'sts:encode';
+import type { Result } from 'sts:result';
+
+export type JsonArray = JsonValue[];
+export type JsonObject = {
+  [key: string]: JsonValue;
+};
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+type LosslessJsonArray = LosslessJsonValue[];
+type LosslessJsonObject = {
+  [key: string]: LosslessJsonValue;
+};
+export type LosslessJsonValue =
+  | string
+  | number
+  | bigint
+  | boolean
+  | null
+  | LosslessJsonObject
+  | LosslessJsonArray;
+
+export type JsonLikeArray = JsonLikeValue[];
+export type JsonLikeObject = {
+  [key: string]: JsonLikeValue;
+};
+export type JsonLikeValue =
+  | string
+  | number
+  | boolean
+  | bigint
+  | null
+  | undefined
+  | JsonLikeObject
+  | JsonLikeArray;
+
+export interface JsonParseOptions {
+  int64?: 'default' | 'lossless';
+}
+
+export type JsonStringifyBigintMode = 'number' | 'reject' | 'string';
+
+export interface JsonStringifyOptions {
+  int64?: 'default' | 'string' | 'lossless';
+  readonly bigint?: JsonStringifyBigintMode;
+}
+
+export class JsonParseFailure extends Failure {
+  constructor(cause?: unknown);
+}
+
+export class JsonStringifyFailure extends Failure {
+  constructor(cause?: unknown);
+}
+
+export function parseJson(text: string): Result<JsonValue, JsonParseFailure>;
+export function parseJson(
+  text: string,
+  options: JsonParseOptions & { int64: 'lossless' },
+): Result<LosslessJsonValue, JsonParseFailure>;
+export function parseJson(
+  text: string,
+  options?: JsonParseOptions,
+): Result<JsonValue | LosslessJsonValue, 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,
+  options?: JsonStringifyOptions,
+): Result<string, JsonStringifyFailure>;
+export function parseAndDecode<T, E>(
+  text: string,
+  decoder: Decoder<T, E>,
+): Result<T, JsonParseFailure | E>;
+export function encodeAndStringify<T, E>(
+  value: T,
+  encoder: Encoder<T, JsonValue, E>,
+): Result<string, E | JsonStringifyFailure>;
+export function isJsonValue(value: unknown): value is JsonValue;
+export function parseJsonLike(text: string): Result<JsonLikeValue, JsonParseFailure>;
+export function stringifyJsonLike(
+  value: JsonLikeValue,
+  options?: JsonStringifyOptions,
+): Result<string, JsonStringifyFailure>;
+export function decodeJson<T, E>(
+  text: string,
+  decoder: Decoder<T, E>,
+): Result<T, E | JsonParseFailure>;
+export function encodeJson<T, E>(
+  value: T,
+  encoder: Encoder<T, JsonLikeValue, E>,
+  options?: JsonStringifyOptions,
+): Result<string, E | JsonStringifyFailure>;
+export function isJsonLikeValue(value: unknown): value is JsonLikeValue;

package/src/stdlib/match.d.ts

@@ -0,0 +1,11 @@
+export type MatchArm<TValue = unknown, TResult = unknown> = (value: TValue) => TResult;
+
+export function where<TValue, TResult>(
+  arm: (value: TValue) => TResult,
+  predicate: (value: TValue) => unknown,
+): (value: TValue) => TResult;
+
+export function Match<TArm extends MatchArm<any, any>>(
+  value: unknown,
+  arms: readonly [TArm, ...TArm[]],
+): ReturnType<TArm>;

package/src/stdlib/numerics.d.ts

@@ -0,0 +1,45 @@
+export type NumberLike = number;
+export type BigintLike = bigint;
+export type Numeric = NumberLike | BigintLike;
+export type __soundscript_builtin_bigint = bigint;
+export type f64 = number;
+export type f32 = number & { readonly __soundscript_builtin_f32_brand: 'f32' };
+export type i8 = number & { readonly __soundscript_builtin_i8_brand: 'i8' };
+export type i16 = number & { readonly __soundscript_builtin_i16_brand: 'i16' };
+export type i32 = number & { readonly __soundscript_builtin_i32_brand: 'i32' };
+export type i64 = bigint & { readonly __soundscript_builtin_i64_brand: 'i64' };
+export type u8 = number & { readonly __soundscript_builtin_u8_brand: 'u8' };
+export type u16 = number & { readonly __soundscript_builtin_u16_brand: 'u16' };
+export type u32 = number & { readonly __soundscript_builtin_u32_brand: 'u32' };
+export type u64 = bigint & { readonly __soundscript_builtin_u64_brand: 'u64' };
+type integral_number = number & {
+  readonly __soundscript_builtin_int_refinement_brand: 'Int';
+};
+export type Int = integral_number | i8 | i16 | i32 | i64 | u8 | u16 | u32 | u64 | bigint;
+export type Float = number & {
+  readonly __soundscript_builtin_float_refinement_brand: 'Float';
+};
+
+export function isInt(value: Numeric): value is Int;
+export function isFloat(value: Numeric): value is Float;
+export function equals(left: Numeric, right: Numeric): boolean;
+export function fitsF32(value: Numeric): value is f32;
+export function fitsI8(value: Numeric): value is i8;
+export function fitsI16(value: Numeric): value is i16;
+export function fitsI32(value: Numeric): value is i32;
+export function fitsI64(value: Numeric): value is i64;
+export function fitsU8(value: Numeric): value is u8;
+export function fitsU16(value: Numeric): value is u16;
+export function fitsU32(value: Numeric): value is u32;
+export function fitsU64(value: Numeric): value is u64;
+
+export function __numericWasmLeaf<T>(value: unknown): T;
+export function F32(value: number): f32;
+export function I8(value: number): i8;
+export function I16(value: number): i16;
+export function I32(value: number): i32;
+export function I64(value: number | bigint): i64;
+export function U8(value: number): u8;
+export function U16(value: number): u16;
+export function U32(value: number): u32;
+export function U64(value: number | bigint): u64;