effect 4.0.6 → 4.1.0

package/dist/Schema.js

@@ -17,6 +17,13 @@ import * as BigDecimal_ from "./BigDecimal.js";
 import * as ByteSize_ from "./ByteSize.js";
 import * as Cause_ from "./Cause.js";
 import * as Chunk_ from "./Chunk.js";
+import * as Aead_ from "./crypto/Aead.js";
+import * as Cipher_ from "./crypto/Cipher.js";
+import * as KeyAgreement_ from "./crypto/KeyAgreement.js";
+import * as KeyFormat_ from "./crypto/KeyFormat.js";
+import * as KeyWrap_ from "./crypto/KeyWrap.js";
+import * as Mac_ from "./crypto/Mac.js";
+import * as Signature_ from "./crypto/Signature.js";
 import * as Data from "./Data.js";
 import * as DateTime from "./DateTime.js";
 import * as Duration_ from "./Duration.js";
@@ -2127,11 +2134,18 @@ export function extendTo(fields, derive) {
  *
  * **Gotchas**
  *
+ * Dynamic records reject value schemas wrapped with {@link optionalKey} or
+ * {@link optional}. Index signatures already allow keys to be absent; use
+ * {@link UndefinedOr} when existing entries may contain `undefined`. Optional
+ * value schemas remain valid for finite literal keys, which become declared
+ * properties.
+ *
  * When decoded or encoded key transformations produce the same property key,
  * sequential parsing applies selected own properties in selection order, so
  * the later selected property overwrites the earlier value. Dynamic key
- * selection always examines own properties. Finite literal keys are declared
- * fields and may therefore be inherited. Output key order is not guaranteed.
+ * selection always examines own properties. Finite literal and enum keys are
+ * declared fields and may therefore be inherited. Output key order is not
+ * guaranteed.
  *
  * **Example** (Defining a string-keyed record of numbers)
  *
@@ -3457,9 +3471,8 @@ export function link() {
  * )
  *
  * const result = Schema.decodeUnknownResult(schema)({ password: "123456", confirmPassword: "1234567" })
- * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Pointer") {
- *   result.failure.issue.issue.path // => ["password"]
- * }
+ * const message = Result.isFailure(result) ? result.failure.message : ""
+ * message // => "password and confirmPassword must match\n  at [\"password\"]"
  * ```
  *
  * **Example** (Reporting multiple failures at once)
@@ -3479,9 +3492,8 @@ export function link() {
  * )
  *
  * const result = Schema.decodeUnknownResult(schema)({ a: 1, b: 0, c: 0 })
- * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Composite") {
- *   result.failure.issue.issue.issues.map((issue) => issue._tag === "Pointer" ? issue.path : []) // => [["b"], ["c"]]
- * }
+ * const message = Result.isFailure(result) ? result.failure.message : ""
+ * message // => "b must be greater than 0\n  at [\"b\"]\nc must be greater than 0\n  at [\"c\"]"
  * ```
  *
  * @stability stable
@@ -3567,7 +3579,7 @@ export function isPattern(regExp, annotations) {
   const source = regExp.source;
   const flags = regExp.flags;
   const canExport = /^[dg]*uy?$/.test(flags);
-  const runtimeRegExp = flags === "" ? `new RegExp(${format(source)})` : `new RegExp(${format(source)}, ${format(flags)})`;
+  const runtimeRegExp = flags === "" ? `new globalThis.RegExp(${format(source)})` : `new globalThis.RegExp(${format(source)}, ${format(flags)})`;
   return SchemaAST.isPattern(regExp, {
     toJsonSchema: () => canExport ? {
       pattern: flags.endsWith("y") ? `^(?:${source})` : source
@@ -3709,7 +3721,7 @@ export function isUUID(version, annotations) {
     ...annotations
   });
 }
-const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/u;
 /**
  * Validates that a string has the GUID / UUID textual shape.
  *
@@ -3742,21 +3754,22 @@ export function isGUID(annotations) {
       id: "effect/schema/isGUID",
       payload: null
     },
-    toJsonSchema: () => ({
-      pattern: GUID_REGEXP.source
-    }),
     toCode: () => ({
       runtime: "Schema.isGUID()"
     }),
     ...annotations
   });
 }
+const ULID_REGEXP = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/u;
 /**
  * Validates that a string is a valid ULID (Universally Unique Lexicographically
  * Sortable Identifier).
  *
  * **Details**
  *
+ * Accepts uppercase and lowercase characters. The first character must be
+ * between `0` and `7` so the value fits in 128 bits.
+ *
  * JSON Schema:
  *
  * This check corresponds to a `pattern` constraint in JSON Schema that matches
@@ -3772,21 +3785,60 @@ export function isGUID(annotations) {
  * @since 4.0.0
  */
 export function isULID(annotations) {
-  const regExp = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
-  return isPattern(regExp, {
+  return isPattern(ULID_REGEXP, {
     representation: {
       id: "effect/schema/isULID",
       payload: null
     },
-    toJsonSchema: () => ({
-      pattern: regExp.source
-    }),
     toCode: () => ({
       runtime: "Schema.isULID()"
     }),
     ...annotations
   });
 }
+// oxlint-disable-next-line no-control-regex
+const ASCII_REGEXP = /^[\x00-\x7F]*$/u;
+/**
+ * Validates that a string contains only ASCII characters.
+ *
+ * **When to use**
+ *
+ * Use when a value must stay within the 7-bit ASCII range, for example
+ * identifiers, protocol tokens, or data sent to systems that reject
+ * non-ASCII input.
+ *
+ * **Details**
+ *
+ * This check accepts strings whose characters are all in the range `U+0000`
+ * to `U+007F`, including control characters and the empty string.
+ *
+ * JSON Schema:
+ *
+ * This check corresponds to a `pattern` constraint in JSON Schema that matches
+ * ASCII-only strings.
+ *
+ * Arbitrary:
+ *
+ * During arbitrary generation, this applies a `patterns`
+ * constraint to ensure generated strings match the ASCII pattern.
+ *
+ * @stability unstable
+ * @category validation
+ * @since 4.0.6
+ */
+export function isAscii(annotations) {
+  return isPattern(ASCII_REGEXP, {
+    expected: "an ASCII string",
+    representation: {
+      id: "effect/schema/isAscii",
+      payload: null
+    },
+    toCode: () => ({
+      runtime: "Schema.isAscii()"
+    }),
+    ...annotations
+  });
+}
 /**
  * Validates that a string is valid Base64 encoded data.
  *
@@ -4087,15 +4139,17 @@ const CAPITALIZED_PATTERN = "^(?:[^a-z][\\s\\S]*)?$";
  * @since 4.0.0
  */
 export function isCapitalized(annotations) {
-  const regExp = new globalThis.RegExp(CAPITALIZED_PATTERN);
-  return makeFilter(s => s.charAt(0).toUpperCase() === s.charAt(0), {
+  return makeFilter(s => {
+    const [first = ""] = s;
+    return first.toUpperCase() === first;
+  }, {
     expected: "a string with the first character in uppercase",
     representation: {
       id: "effect/schema/isCapitalized",
       payload: null
     },
     toJsonSchema: () => [{
-      pattern: regExp.source
+      pattern: CAPITALIZED_PATTERN
     }, true],
     toCode: () => ({
       runtime: "Schema.isCapitalized()"
@@ -4124,15 +4178,17 @@ const UNCAPITALIZED_PATTERN = "^(?:[^A-Z][\\s\\S]*)?$";
  * @since 4.0.0
  */
 export function isUncapitalized(annotations) {
-  const regExp = new globalThis.RegExp(UNCAPITALIZED_PATTERN);
-  return makeFilter(s => s.charAt(0).toLowerCase() === s.charAt(0), {
+  return makeFilter(s => {
+    const [first = ""] = s;
+    return first.toLowerCase() === first;
+  }, {
     expected: "a string with the first character in lowercase",
     representation: {
       id: "effect/schema/isUncapitalized",
       payload: null
     },
     toJsonSchema: () => [{
-      pattern: regExp.source
+      pattern: UNCAPITALIZED_PATTERN
     }, true],
     toCode: () => ({
       runtime: "Schema.isUncapitalized()"
@@ -4690,7 +4746,7 @@ function encodeDatePayload(date) {
   return date.toISOString();
 }
 function formatDateRuntime(date) {
-  return `new Date(${format(date.getTime())})`;
+  return `new globalThis.Date(${format(date.getTime())})`;
 }
 /**
  * Validates that a Date is greater than the specified value (exclusive).
@@ -6228,8 +6284,7 @@ export const DateFromString = /*#__PURE__*/DateString.pipe(/*#__PURE__*/decodeTo
  */
 export const DateFromMillis = /*#__PURE__*/Int.pipe(/*#__PURE__*/decodeTo(Date, SchemaTransformation.dateFromMillis));
 const JsonString = /*#__PURE__*/String.annotate({
-  expected: "a string that will be decoded as JSON",
-  contentMediaType: "application/json"
+  expected: "a string that will be decoded as JSON"
 });
 /**
  * Returns a schema that decodes a JSON string and then decodes the parsed value
@@ -8377,6 +8432,20 @@ const durationFromMillis = /*#__PURE__*/SchemaTransformation.transform({
   decode: i => Duration_.millis(i),
   encode: a => Duration_.toMillis(a)
 });
+const durationFromIsoString = /*#__PURE__*/SchemaTransformation.transformEffect({
+  decode: (s, options) => Option_.match(Duration_.fromIso(s), {
+    onNone: () => Effect.fail(new SchemaIssue.InvalidValue({
+      expected: "an ISO 8601 duration without years or months"
+    }, s, options)),
+    onSome: Effect.succeed
+  }),
+  encode: (a, options) => Option_.match(Duration_.formatIso(a), {
+    onNone: () => Effect.fail(new SchemaIssue.InvalidValue({
+      expected: "a finite Duration"
+    }, a, options)),
+    onSome: Effect.succeed
+  })
+});
 /**
  * Schema for `Duration` values.
  *
@@ -8516,6 +8585,30 @@ export const DurationFromNanos = /*#__PURE__*/BigInt.pipe(/*#__PURE__*/decodeTo(
  * @since 3.10.0
  */
 export const DurationFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decodeTo(Duration, durationFromMillis));
+/**
+ * Schema that decodes an ISO 8601 duration string into a `Duration`.
+ *
+ * **Details**
+ *
+ * Decoding:
+ * - A string accepted by `Duration.fromIso` is decoded as a `Duration`, such
+ *   as `"PT1H30M"`, `"P1W2D"`, or `"-PT0.5S"`. Years and months are rejected
+ *   because they have no fixed length.
+ *
+ * Encoding:
+ * - A finite `Duration` is encoded with `Duration.formatIso`, using days,
+ *   hours, minutes, and seconds. Encoding fails for `Duration.infinity` and
+ *   `Duration.negativeInfinity`.
+ *
+ * @see {@link DurationFromString} for the `"5 seconds"` string format
+ *
+ * @stability stable
+ * @category schemas
+ * @since 4.1.0
+ */
+export const DurationFromIsoString = /*#__PURE__*/String.annotate({
+  expected: "an ISO 8601 duration string that will be decoded as a Duration"
+}).pipe(/*#__PURE__*/decodeTo(Duration, durationFromIsoString));
 /**
  * Schema for supported DNS record types such as `"A"` or `"SRV"`.
  *
@@ -8745,6 +8838,568 @@ export const DnsTxtRecord = /*#__PURE__*/dnsRecordOfType("TXT", {
 export const DnsRecord = /*#__PURE__*/Union([DnsARecord, DnsAaaaRecord, DnsCaaRecord, DnsCnameRecord, DnsMxRecord, DnsNaptrRecord, DnsNsRecord, DnsPtrRecord, DnsSoaRecord, DnsSrvRecord, DnsTlsaRecord, DnsTxtRecord]).annotate({
   identifier: "DnsRecord"
 });
+const cryptoAlgorithmEquals = (self, that) => self === that || self.name === that.name && self.hash?.name === that.hash?.name && self.saltLength === that.saltLength;
+const cryptoDigestCode = hash => `Digest.${hash.name.toLowerCase().replace("-", "")}`;
+const cryptoAlgorithmCode = (family, algorithm) => {
+  if (algorithm.modulusLength === undefined || algorithm.hash === undefined || algorithm._tag === undefined) {
+    const code = `${family}.${algorithm.name}`;
+    return algorithm.hash === undefined ? code : `{ ...${code}, hash: ${cryptoDigestCode(algorithm.hash)} }`;
+  }
+  const factory = algorithm._tag.charAt(0).toLowerCase() + algorithm._tag.slice(1);
+  const saltLength = algorithm.saltLength === undefined ? "" : `, saltLength: ${algorithm.saltLength}`;
+  return `${family}.${factory}({ hash: ${cryptoDigestCode(algorithm.hash)}, modulusLength: ${algorithm.modulusLength}${saltLength} })`;
+};
+const cryptoAlgorithmPayload = algorithm => {
+  const payload = {
+    name: algorithm.name
+  };
+  if (algorithm.hash !== undefined) payload.hash = algorithm.hash.name;
+  if (algorithm.modulusLength !== undefined) payload.modulusLength = algorithm.modulusLength;
+  if (algorithm.saltLength !== undefined) payload.saltLength = algorithm.saltLength;
+  return payload;
+};
+const declareCryptoKey = (name, family, type, is, algorithm) => {
+  const code = cryptoAlgorithmCode(family, algorithm);
+  const forbidden = SchemaGetter.forbidden(() => `Cannot serialize ${family}.${type} values as JSON, use Schema.${name}FromFormat to read and write keys`);
+  return declare(u => is(u) && cryptoAlgorithmEquals(u.algorithm, algorithm), {
+    expected: `${family}.${type} for ${algorithm.name}`,
+    representation: {
+      id: `effect/crypto/${name}`,
+      payload: cryptoAlgorithmPayload(algorithm)
+    },
+    toCode: () => ({
+      runtime: `Schema.${name}(${code})`,
+      Type: `${family}.${type}`,
+      importDeclarations: [`import * as ${family} from "effect/crypto/${family}"`, ...(code.includes("Digest.") ? [`import * as Digest from "effect/crypto/Digest"`] : [])]
+    }),
+    toCodecJson: () => link()(Unknown, {
+      decode: forbidden,
+      encode: forbidden
+    }),
+    // Keys have no Arbitrary: linking to `Never` makes derivation fail.
+    toCodecArbitrary: () => link()(Never, {
+      decode: forbidden,
+      encode: forbidden
+    }),
+    toFormatter: () => key => globalThis.String(key),
+    toEquivalence: () => (self, that) => self === that
+  });
+};
+const cryptoIssue = (error, input, options) => new SchemaIssue.InvalidValue({
+  message: error.message,
+  cause: error
+}, input, options);
+const cryptoForbiddenEncode = (name, key, options) => Effect.fail(new SchemaIssue.Forbidden({
+  message: `Schema.${name} only decodes, pass { allowEncode: true } to encode the key`
+}, key, options));
+const cryptoKeyFromBytes = (name, to, fromBytes, toBytes) => Uint8Array.pipe(decodeTo(to, SchemaTransformation.transformEffect({
+  decode: (bytes, options) => Effect.mapError(fromBytes(bytes), error => cryptoIssue(error, bytes, options)),
+  encode: (key, options) => toBytes === undefined ? cryptoForbiddenEncode(name, key, options) : Effect.mapError(toBytes(key), error => cryptoIssue(error, key, options))
+})));
+const CryptoJsonWebKeyMember = /*#__PURE__*/optionalKey(String);
+// The JWK members of RFC 7517 and RFC 7518 that `KeyFormat` reads and writes.
+// Other members are dropped.
+const CryptoJsonWebKey = /*#__PURE__*/Struct({
+  kty: CryptoJsonWebKeyMember,
+  crv: CryptoJsonWebKeyMember,
+  alg: CryptoJsonWebKeyMember,
+  use: CryptoJsonWebKeyMember,
+  key_ops: /*#__PURE__*/optionalKey(/*#__PURE__*/ArraySchema(String)),
+  ext: /*#__PURE__*/optionalKey(Boolean),
+  k: CryptoJsonWebKeyMember,
+  x: CryptoJsonWebKeyMember,
+  y: CryptoJsonWebKeyMember,
+  d: CryptoJsonWebKeyMember,
+  n: CryptoJsonWebKeyMember,
+  e: CryptoJsonWebKeyMember,
+  p: CryptoJsonWebKeyMember,
+  q: CryptoJsonWebKeyMember,
+  dp: CryptoJsonWebKeyMember,
+  dq: CryptoJsonWebKeyMember,
+  qi: CryptoJsonWebKeyMember,
+  oth: /*#__PURE__*/optionalKey(/*#__PURE__*/ArraySchema(/*#__PURE__*/Struct({
+    r: CryptoJsonWebKeyMember,
+    d: CryptoJsonWebKeyMember,
+    t: CryptoJsonWebKeyMember
+  })))
+});
+const cryptoFormatData = format => format._tag === "jwk" ? CryptoJsonWebKey : format.pem ? String : Uint8Array;
+const cryptoKeyFromFormat = (name, to, format, decode, canEncode) => {
+  // PKCS#1 and SEC1 are read only.
+  const writable = canEncode && format._tag !== "pkcs1" && format._tag !== "sec1";
+  return cryptoFormatData(format).pipe(decodeTo(to, SchemaTransformation.transformEffect({
+    decode: (data, options) =>
+    // Secret JWK decoding is synchronous, but all format schemas are async-only.
+    Effect.flatMap(Effect.promise(() => Promise.resolve()), () => Effect.mapError(decode(data), error => cryptoIssue(error, data, options))),
+    encode: (key, options) => writable ? Effect.mapError(KeyFormat_.encode(format, key), error => cryptoIssue(error, key, options)) : cryptoForbiddenEncode(name, key, options)
+  })));
+};
+/**
+ * Schema for live `Mac.Key` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link MacKeyFromFormat} or {@link MacKeyFromBytes} to read and write keys.
+ * Keys display redacted, compare by reference, and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const MacKey = algorithm => declareCryptoKey("MacKey", "Mac", "Key", Mac_.isKey, algorithm);
+/**
+ * Schema that decodes raw key bytes into a `Mac.Key`.
+ *
+ * **Details**
+ *
+ * Decoding runs `Mac.key`, which is synchronous, so the schema works with
+ * `Schema.decodeSync`. Under `Config.schema` the bytes are read as base64. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`.
+ *
+ * **Example** (Reading an HMAC key from the environment)
+ *
+ * ```ts import.meta.vitest
+ * import { Config, ConfigProvider, Effect, Schema } from "effect"
+ * import { Mac } from "effect/crypto"
+ *
+ * const config = Config.schema(Schema.MacKeyFromBytes(Mac.hmacSha256), "HMAC_KEY")
+ * const provider = ConfigProvider.fromEnv({ env: { HMAC_KEY: "A".repeat(43) + "=" } })
+ * const key = await Effect.runPromise(Effect.provide(config, ConfigProvider.layer(provider)))
+ * key.algorithm.name // => "hmacSha256"
+ * ```
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const MacKeyFromBytes = (algorithm, options) => cryptoKeyFromBytes("MacKeyFromBytes", MacKey(algorithm), bytes => Mac_.key(algorithm, bytes), options?.allowEncode === true ? Mac_.toBytes : undefined);
+/**
+ * Schema that decodes a `Mac.Key` from a JWK with `KeyFormat.decodeSecret`.
+ *
+ * **Details**
+ *
+ * Decoding returns an Effect, so use the async decoding functions:
+ * `Schema.decodeSync` throws. A `CryptoError` becomes an `InvalidValue` issue
+ * whose `cause` is the error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const MacKeyFromFormat = (format, algorithm, options) => cryptoKeyFromFormat("MacKeyFromFormat", MacKey(algorithm), format, data => KeyFormat_.decodeSecret(format, algorithm, data), options?.allowEncode === true);
+/**
+ * Schema for live `Aead.Key` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link AeadKeyFromFormat} or {@link AeadKeyFromBytes} to read and write
+ * keys. Keys display redacted, compare by reference, and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const AeadKey = algorithm => declareCryptoKey("AeadKey", "Aead", "Key", Aead_.isKey, algorithm);
+/**
+ * Schema that decodes raw key bytes into an `Aead.Key`.
+ *
+ * **Details**
+ *
+ * Decoding runs `Aead.key`, which is synchronous, so the schema works with
+ * `Schema.decodeSync`. Under `Config.schema` the bytes are read as base64. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const AeadKeyFromBytes = (algorithm, options) => cryptoKeyFromBytes("AeadKeyFromBytes", AeadKey(algorithm), bytes => Aead_.key(algorithm, bytes), options?.allowEncode === true ? Aead_.toBytes : undefined);
+/**
+ * Schema that decodes an `Aead.Key` from a JWK with `KeyFormat.decodeSecret`.
+ *
+ * **Details**
+ *
+ * Decoding returns an Effect, so use the async decoding functions:
+ * `Schema.decodeSync` throws. A `CryptoError` becomes an `InvalidValue` issue
+ * whose `cause` is the error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const AeadKeyFromFormat = (format, algorithm, options) => cryptoKeyFromFormat("AeadKeyFromFormat", AeadKey(algorithm), format, data => KeyFormat_.decodeSecret(format, algorithm, data), options?.allowEncode === true);
+/**
+ * Schema for live `Cipher.Key` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link CipherKeyFromFormat} or {@link CipherKeyFromBytes} to read and
+ * write keys. Keys display redacted, compare by reference, and have no
+ * `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const CipherKey = algorithm => declareCryptoKey("CipherKey", "Cipher", "Key", Cipher_.isKey, algorithm);
+/**
+ * Schema that decodes raw key bytes into a `Cipher.Key`.
+ *
+ * **Details**
+ *
+ * Decoding runs `Cipher.key`, which is synchronous, so the schema works with
+ * `Schema.decodeSync`. Under `Config.schema` the bytes are read as base64. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const CipherKeyFromBytes = (algorithm, options) => cryptoKeyFromBytes("CipherKeyFromBytes", CipherKey(algorithm), bytes => Cipher_.key(algorithm, bytes), options?.allowEncode === true ? Cipher_.toBytes : undefined);
+/**
+ * Schema that decodes a `Cipher.Key` from a JWK with
+ * `KeyFormat.decodeSecret`.
+ *
+ * **Details**
+ *
+ * Decoding returns an Effect, so use the async decoding functions:
+ * `Schema.decodeSync` throws. A `CryptoError` becomes an `InvalidValue` issue
+ * whose `cause` is the error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const CipherKeyFromFormat = (format, algorithm, options) => cryptoKeyFromFormat("CipherKeyFromFormat", CipherKey(algorithm), format, data => KeyFormat_.decodeSecret(format, algorithm, data), options?.allowEncode === true);
+/**
+ * Schema for live `Signature.PublicKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link SignaturePublicKeyFromFormat} or {@link SignaturePublicKeyFromBytes}
+ * to read and write keys. Keys compare by reference and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const SignaturePublicKey = algorithm => declareCryptoKey("SignaturePublicKey", "Signature", "PublicKey", Signature_.isPublicKey, algorithm);
+/**
+ * Schema that decodes a raw public key into a `Signature.PublicKey`: 32 bytes
+ * for Ed25519, or an uncompressed SEC1 point for ECDSA.
+ *
+ * **Details**
+ *
+ * Decoding runs `Signature.publicKey`, which is synchronous, so the schema
+ * works with `Schema.decodeSync`. Under `Config.schema` the bytes are read as
+ * base64. A `CryptoError` becomes an `InvalidValue` issue whose `cause` is
+ * the error. RSA public keys have no raw form, so passing an RSA algorithm is
+ * a type error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const SignaturePublicKeyFromBytes = algorithm => cryptoKeyFromBytes("SignaturePublicKeyFromBytes", SignaturePublicKey(algorithm), bytes => Signature_.publicKey(algorithm, bytes), Signature_.toBytes);
+/**
+ * Schema that decodes a `Signature.PublicKey` with
+ * `KeyFormat.decodePublic` and encodes it with `KeyFormat.encode`.
+ *
+ * **Details**
+ *
+ * The format must hold public keys: `KeyFormat.spki`, `KeyFormat.jwk`, or
+ * `KeyFormat.pem(KeyFormat.spki)`. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const SignaturePublicKeyFromFormat = (format, algorithm) => cryptoKeyFromFormat("SignaturePublicKeyFromFormat", SignaturePublicKey(algorithm), format, data => KeyFormat_.decodePublic(format, algorithm, data), true);
+/**
+ * Schema for live `Signature.PrivateKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link SignaturePrivateKeyFromFormat} or
+ * {@link SignaturePrivateKeyFromBytes} to read and write keys. Keys display
+ * redacted, compare by reference, and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const SignaturePrivateKey = algorithm => declareCryptoKey("SignaturePrivateKey", "Signature", "PrivateKey", Signature_.isPrivateKey, algorithm);
+/**
+ * Schema that decodes an Ed25519 seed into a `Signature.PrivateKey`.
+ *
+ * **Details**
+ *
+ * Decoding runs `Signature.privateKey`, which is synchronous, so the schema
+ * works with `Schema.decodeSync`. Under `Config.schema` the bytes are read as
+ * base64. A `CryptoError` becomes an `InvalidValue` issue whose `cause` is
+ * the error. ECDSA and RSA private keys have no raw form, so passing them is
+ * a type error. Encoding fails with a `Forbidden` issue unless `allowEncode`
+ * is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const SignaturePrivateKeyFromBytes = (algorithm, options) => cryptoKeyFromBytes("SignaturePrivateKeyFromBytes", SignaturePrivateKey(algorithm), bytes => Signature_.privateKey(algorithm, bytes), options?.allowEncode === true ? Signature_.toBytes : undefined);
+/**
+ * Schema that decodes a `Signature.PrivateKey` with
+ * `KeyFormat.decodePrivate`.
+ *
+ * **Details**
+ *
+ * The format must hold private keys: `KeyFormat.pkcs8`, `KeyFormat.jwk`,
+ * `KeyFormat.pkcs1`, `KeyFormat.sec1`, or their PEM forms. A format for
+ * another role is a type error. Decoding runs the runtime's key import, so
+ * use the async decoding functions: `Schema.decodeSync` throws. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`,
+ * and always for the read-only PKCS#1 and SEC1 formats.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const SignaturePrivateKeyFromFormat = (format, algorithm, options) => cryptoKeyFromFormat("SignaturePrivateKeyFromFormat", SignaturePrivateKey(algorithm), format, data => KeyFormat_.decodePrivate(format, algorithm, data), options?.allowEncode === true);
+/**
+ * Schema for live `KeyAgreement.PublicKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyAgreementPublicKeyFromFormat} or
+ * {@link KeyAgreementPublicKeyFromBytes} to read and write keys. Keys compare
+ * by reference and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyAgreementPublicKey = algorithm => declareCryptoKey("KeyAgreementPublicKey", "KeyAgreement", "PublicKey", KeyAgreement_.isPublicKey, algorithm);
+/**
+ * Schema that decodes a raw public key into a `KeyAgreement.PublicKey`: 32
+ * bytes for X25519, or an uncompressed SEC1 point for ECDH.
+ *
+ * **Details**
+ *
+ * Decoding runs `KeyAgreement.publicKey`, which is synchronous, so the schema
+ * works with `Schema.decodeSync`. Under `Config.schema` the bytes are read as
+ * base64. A `CryptoError` becomes an `InvalidValue` issue whose `cause` is
+ * the error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyAgreementPublicKeyFromBytes = algorithm => cryptoKeyFromBytes("KeyAgreementPublicKeyFromBytes", KeyAgreementPublicKey(algorithm), bytes => KeyAgreement_.publicKey(algorithm, bytes), KeyAgreement_.toBytes);
+/**
+ * Schema that decodes a `KeyAgreement.PublicKey` with
+ * `KeyFormat.decodePublic` and encodes it with `KeyFormat.encode`.
+ *
+ * **Details**
+ *
+ * The format must hold public keys: `KeyFormat.spki`, `KeyFormat.jwk`, or
+ * `KeyFormat.pem(KeyFormat.spki)`. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyAgreementPublicKeyFromFormat = (format, algorithm) => cryptoKeyFromFormat("KeyAgreementPublicKeyFromFormat", KeyAgreementPublicKey(algorithm), format, data => KeyFormat_.decodePublic(format, algorithm, data), true);
+/**
+ * Schema for live `KeyAgreement.PrivateKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyAgreementPrivateKeyFromFormat} or
+ * {@link KeyAgreementPrivateKeyFromBytes} to read and write keys. Keys
+ * display redacted, compare by reference, and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyAgreementPrivateKey = algorithm => declareCryptoKey("KeyAgreementPrivateKey", "KeyAgreement", "PrivateKey", KeyAgreement_.isPrivateKey, algorithm);
+/**
+ * Schema that decodes an X25519 private key into a
+ * `KeyAgreement.PrivateKey`.
+ *
+ * **Details**
+ *
+ * Decoding runs `KeyAgreement.privateKey`, which is synchronous, so the
+ * schema works with `Schema.decodeSync`. Under `Config.schema` the bytes are
+ * read as base64. A `CryptoError` becomes an `InvalidValue` issue whose
+ * `cause` is the error. ECDH private keys have no raw form, so passing them
+ * is a type error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyAgreementPrivateKeyFromBytes = (algorithm, options) => cryptoKeyFromBytes("KeyAgreementPrivateKeyFromBytes", KeyAgreementPrivateKey(algorithm), bytes => KeyAgreement_.privateKey(algorithm, bytes), options?.allowEncode === true ? KeyAgreement_.toBytes : undefined);
+/**
+ * Schema that decodes a `KeyAgreement.PrivateKey` with
+ * `KeyFormat.decodePrivate`.
+ *
+ * **Details**
+ *
+ * The format must hold private keys: `KeyFormat.pkcs8`, `KeyFormat.jwk`,
+ * `KeyFormat.sec1`, or their PEM forms. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error. Encoding fails with a
+ * `Forbidden` issue unless `allowEncode` is `true`, and always for the
+ * read-only PKCS#1 and SEC1 formats.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyAgreementPrivateKeyFromFormat = (format, algorithm, options) => cryptoKeyFromFormat("KeyAgreementPrivateKeyFromFormat", KeyAgreementPrivateKey(algorithm), format, data => KeyFormat_.decodePrivate(format, algorithm, data), options?.allowEncode === true);
+/**
+ * Schema for live AES-KW `KeyWrap.Key` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyWrapKeyFromFormat} or {@link KeyWrapKeyFromBytes} to read and
+ * write keys. Keys display redacted, compare by reference, and have no
+ * `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyWrapKey = algorithm => declareCryptoKey("KeyWrapKey", "KeyWrap", "Key", KeyWrap_.isKey, algorithm);
+/**
+ * Schema that decodes raw key bytes into an AES-KW `KeyWrap.Key`.
+ *
+ * **Details**
+ *
+ * Decoding runs `KeyWrap.key`, which is synchronous, so the schema works with
+ * `Schema.decodeSync`. Under `Config.schema` the bytes are read as base64. A
+ * `CryptoError` becomes an `InvalidValue` issue whose `cause` is the error.
+ * Encoding fails with a `Forbidden` issue unless `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyWrapKeyFromBytes = (algorithm, options) => cryptoKeyFromBytes("KeyWrapKeyFromBytes", KeyWrapKey(algorithm), bytes => KeyWrap_.key(algorithm, bytes), options?.allowEncode === true ? KeyWrap_.toBytes : undefined);
+/**
+ * Schema that decodes an AES-KW `KeyWrap.Key` from a JWK with
+ * `KeyFormat.decodeSecret`.
+ *
+ * **Details**
+ *
+ * Decoding returns an Effect, so use the async decoding functions:
+ * `Schema.decodeSync` throws. A `CryptoError` becomes an `InvalidValue` issue
+ * whose `cause` is the error. Encoding fails with a `Forbidden` issue unless
+ * `allowEncode` is `true`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyWrapKeyFromFormat = (format, algorithm, options) => cryptoKeyFromFormat("KeyWrapKeyFromFormat", KeyWrapKey(algorithm), format, data => KeyFormat_.decodeSecret(format, algorithm, data), options?.allowEncode === true);
+/**
+ * Schema for live RSA-OAEP `KeyWrap.PublicKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyWrapPublicKeyFromFormat} to read and write keys. RSA-OAEP keys
+ * have no raw form. Keys compare by reference and have no `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyWrapPublicKey = algorithm => declareCryptoKey("KeyWrapPublicKey", "KeyWrap", "PublicKey", KeyWrap_.isPublicKey, algorithm);
+/**
+ * Schema that decodes an RSA-OAEP `KeyWrap.PublicKey` with
+ * `KeyFormat.decodePublic` and encodes it with `KeyFormat.encode`.
+ *
+ * **Details**
+ *
+ * The format must hold public keys: `KeyFormat.spki`, `KeyFormat.jwk`, or
+ * `KeyFormat.pem(KeyFormat.spki)`. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyWrapPublicKeyFromFormat = (format, algorithm) => cryptoKeyFromFormat("KeyWrapPublicKeyFromFormat", KeyWrapPublicKey(algorithm), format, data => KeyFormat_.decodePublic(format, algorithm, data), true);
+/**
+ * Schema for live RSA-OAEP `KeyWrap.PrivateKey` values of an algorithm.
+ *
+ * **Details**
+ *
+ * Decoding checks the key's algorithm and returns the key itself. The key has
+ * no JSON form: `toCodecJson` fails with a `Forbidden` issue, so use
+ * {@link KeyWrapPrivateKeyFromFormat} to read and write keys. RSA-OAEP keys
+ * have no raw form. Keys display redacted, compare by reference, and have no
+ * `Arbitrary`.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyWrapPrivateKey = algorithm => declareCryptoKey("KeyWrapPrivateKey", "KeyWrap", "PrivateKey", KeyWrap_.isPrivateKey, algorithm);
+/**
+ * Schema that decodes an RSA-OAEP `KeyWrap.PrivateKey` with
+ * `KeyFormat.decodePrivate`.
+ *
+ * **Details**
+ *
+ * The format must hold private keys: `KeyFormat.pkcs8`, `KeyFormat.jwk`,
+ * `KeyFormat.pkcs1`, or their PEM forms. A format for another role is a type
+ * error. Decoding runs the runtime's key import, so use the async decoding
+ * functions: `Schema.decodeSync` throws. A `CryptoError` becomes an
+ * `InvalidValue` issue whose `cause` is the error. Encoding fails with a
+ * `Forbidden` issue unless `allowEncode` is `true`, and always for the
+ * read-only PKCS#1 format.
+ *
+ * @stability unstable
+ * @category crypto
+ * @since 4.0.0
+ */
+export const KeyWrapPrivateKeyFromFormat = (format, algorithm, options) => cryptoKeyFromFormat("KeyWrapPrivateKeyFromFormat", KeyWrapPrivateKey(algorithm), format, data => KeyFormat_.decodePrivate(format, algorithm, data), options?.allowEncode === true);
 /**
  * Creates a schema for `Exit` values using schemas for the success value, typed
  * failure, and unexpected defect channels.
@@ -9764,7 +10419,7 @@ function makeClass(Inherited, identifier, struct, annotations, proto) {
       return getClassSchema(this).rebuild(ast);
     }
     static make(input, options) {
-      return SchemaParser.make(getClassSchema(this))(input ?? {}, options);
+      return SchemaParser.makeClassSync(SchemaAST.toType(getClassSchema(this).ast), input ?? {}, options, fields => makeClassTrusted(this, fields));
     }
     static makeOption(input, options) {
       return SchemaParser.makeOption(getClassSchema(this))(input ?? {}, options);
@@ -9879,6 +10534,10 @@ function isStruct(schema) {
  *
  * **Gotchas**
  *
+ * To subclass a `Schema.Class`, use `Base.extend<Self>(...)`, even when only
+ * adding methods or getters. Pass `{}` for the fields when none are added.
+ * Plain `class Child extends Base` is unsupported.
+ *
  * Passing `disableChecks: true` skips filters and checks, not parsing of types
  * and structure. Wrong types and shapes are still rejected, and constructor
  * defaults still apply.