@atproto/syntax 0.6.3 → 0.6.4

package/src/datetime.ts

@@ -1,369 +0,0 @@
-import * as isoDatestringValidator from 'iso-datestring-validator'
-
-// Node ESM interop wraps "iso-datestring-validator" as { default: { ... } }
-// @TODO Remove "iso-datestring-validator" dependency
-const { isValidISODateString } = ((m) => m.default ?? m)(isoDatestringValidator)
-
-/**
- * Indicates a date or string is not a valid representation of a datetime
- * according to the atproto
- * {@link https://atproto.com/specs/lexicon#datetime specification}.
- */
-export class InvalidDatetimeError extends Error {}
-
-/**
- * A subset of {@link DatetimeString} that represent valid datetime strings with
- * the format: `YYYY-MM-DDTHH:mm:ss.sssZ`, as returned by `Date.toISOString()
- * for dates between the years 0000 and 9999.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString}
- */
-export type ISODatetimeString =
-  // @TODO Switch to branded types for more accurate type safety.
-  `${string}-${string}-${string}T${string}:${string}:${string}.${string}Z`
-
-/**
- * Represents a {@link Date} that can be safely stringified into a valid atproto
- * {@link DatetimeString} using the {@link Date.toISOString toISOString()}
- * method.
- */
-export interface AtprotoDate extends Date {
-  toISOString(): ISODatetimeString
-}
-
-/**
- * @see {@link AtprotoDate}
- */
-export function assertAtprotoDate(date: Date): asserts date is AtprotoDate {
-  const res = parseDate(date)
-  if (!res.success) {
-    throw new InvalidDatetimeError(res.message)
-  }
-}
-
-/**
- * @see {@link AtprotoDate}
- */
-export function asAtprotoDate(date: Date): AtprotoDate {
-  assertAtprotoDate(date)
-  return date
-}
-
-/**
- * @see {@link AtprotoDate}
- */
-export function isAtprotoDate(date: Date): date is AtprotoDate {
-  return parseDate(date).success
-}
-
-/**
- * @see {@link AtprotoDate}
- */
-export function ifAtprotoDate(date: Date): AtprotoDate | undefined {
-  return isAtprotoDate(date) ? date : undefined
-}
-
-/**
- * Datetime strings in atproto data structures and API calls should meet the
- * {@link https://ijmacd.github.io/rfc3339-iso8601/ intersecting} requirements
- * of the RFC 3339, ISO 8601, and WHATWG HTML datetime standards.
- *
- * @note This literal template type is not accurate enough to ensure that a
- * string is a valid atproto datetime. The {@link DatetimeString} validation
- * functions ({@link assertDatetimeString}, {@link isDatetimeString}, etc)
- * should be used to validate that a string meets the atproto datetime
- * requirements, and the {@link toDatetimeString} function should be used to
- * convert a {@link Date} object into a valid {@link DatetimeString} string.
- *
- * @example "2024-01-15T12:30:00Z"
- * @example "2024-01-15T12:30:00.000Z"
- * @example "2024-01-15T12:30:00+00:00"
- * @example "2024-01-15T11:30:00-01:00"
- * @see {@link https://atproto.com/specs/lexicon#datetime atproto Lexicon datetime format}
- * @see {@link https://www.rfc-editor.org/rfc/rfc3339 RFC 3339}
- * @see {@link https://www.iso.org/iso-8601-date-and-time-format.html ISO 8601}
- */
-export type DatetimeString =
-  // @TODO Switch to branded types for more accurate type safety?
-  | `${string}-${string}-${string}T${string}:${string}:${string}Z`
-  | `${string}-${string}-${string}T${string}:${string}:${string}${'+' | '-'}${string}:${string}`
-
-/**
- * Validates that a string is a valid {@link DatetimeString} format string,
- * throwing an error if it is not.
- *
- * @throws InvalidDatetimeError if the input string does not meet the atproto 'datetime' format requirements.
- * @see {@link DatetimeString}
- */
-export function assertDatetimeString<I>(
-  input: I,
-): asserts input is I & DatetimeString {
-  const result = parseString(input)
-  if (!result.success) {
-    throw new InvalidDatetimeError(result.message)
-  }
-}
-
-/**
- * Casts a string to a {@link DatetimeString} if it is a valid datetime format
- * string, throwing an error if it is not.
- *
- * @throws InvalidDatetimeError if the input string does not meet the atproto 'datetime' format requirements.
- * @see {@link DatetimeString}
- */
-export function asDatetimeString<I>(input: I): I & DatetimeString {
-  assertDatetimeString(input)
-  return input
-}
-
-/**
- * Checks if a string is a valid {@link DatetimeString} format string.
- *
- * @see {@link DatetimeString}
- */
-export function isDatetimeString<I>(input: I): input is I & DatetimeString {
-  return parseString(input).success
-}
-
-/**
- * Matches any ISO-ish datetime string. This is a more lenient check than
- * the strict {@link isDatetimeString} guard, which only allows datetimes that
- * fully conform to the AT Protocol specification (e.g. must include timezone).
- */
-export function isDatetimeStringLenient<I>(
-  input: I,
-): input is I & DatetimeString {
-  // @NOTE the returned type assertion is inaccurate wrt. the DatetimeString
-  // type definition. A more accurate solution would be to use a branded type
-  // instead of a template literal for the "datetime" format
-
-  if (typeof input !== 'string') return false
-
-  try {
-    if (isValidISODateString(input)) return true
-  } catch {
-    // isValidISODateString can throw on some inputs.
-  }
-
-  // @NOTE The "iso-datestring-validator" implementation is *not* compliant with
-  // the AT Protocol datetime specification. In particular, it rejects some
-  // valid AT Protocol datetimes (eg: "1985-04-12T23:20:50.1235678912345Z",
-  // "1985-04-12T23:20:50.123+01:45", "1985-04-12T23:20:50.1234567890Z"). For
-  // this reason, we run "isDatetimeString" validation if "isValidISODateString"
-  // does not return true.
-  return isDatetimeString(input)
-}
-
-/**
- * Returns the input if it is a valid {@link DatetimeString} format string, or
- * `undefined` if it is not.
- *
- * @see {@link DatetimeString}
- */
-export function ifDatetimeString<I>(
-  input: I,
-): undefined | (I & DatetimeString) {
-  return isDatetimeString(input) ? input : undefined
-}
-
-/**
- * Returns the current date and time as a {@link DatetimeString}.
- *
- * @see {@link DatetimeString}
- */
-export function currentDatetimeString(): DatetimeString {
-  return toDatetimeString(new Date())
-}
-
-/**
- * Converts any {@link Date} into a {@link DatetimeString} if possible, throwing
- * an error if the date is not a valid atproto datetime.
- *
- * This is short-hand for `asAtprotoDate(date).toISOString()`.
- *
- * @throws InvalidDatetimeError if the input date is not a valid atproto datetime (eg, it is too far in the future or past, or it normalizes to a negative year).
- * @see {@link DatetimeString}
- */
-export function toDatetimeString(date: Date): DatetimeString {
-  return asAtprotoDate(date).toISOString()
-}
-
-/**
- * Takes a flexible datetime string and normalizes its representation.
- *
- * This function will work with any valid value that can be parsed as a date. It
- * *additionally* is more flexible about accepting datetimes that are missing
- * timezone information, and normalizing them to a valid atproto datetime.
- *
- * One use-case is a consistent, sortable string. Another is to work with older
- * invalid createdAt datetimes.
- *
- * @note This function might return different normalized strings for the same
- * input depending on the timezone of the machine it is run on, since it will
- * attempt to parse the input "as is" if it fails to parse with an explicit
- * timezone.
- *
- * @returns ISODatetimeString - a valid atproto datetime with millisecond precision (3 sub-second digits) and UTC timezone with trailing 'Z' syntax.
- * @throws InvalidDatetimeError - if the input string could not be parsed as a datetime, even with permissive parsing.
- */
-export function normalizeDatetime(dtStr: string): ISODatetimeString {
-  if (
-    // Explicit timezone offset
-    /[+-]\d\d:?\d\d/.test(dtStr) ||
-    // 'Z' timezone designator
-    /\dZ\b/.test(dtStr) ||
-    // Timezone abbreviation (eg. "EST", "PST", "UTC", "GMT", etc), as in:
-    // > Tue Mar 17 2026 16:38:44 PST (Pacific Standard Time)
-    /\b[A-Z]{3,4}\b/.test(dtStr)
-  ) {
-    // Since we do have a timezone designator, we can try parsing "as is" and
-    // should get consistent results regardless of local timezone.
-
-    // @NOTE NodeJS will reject dates with an un-recognized timezone designator
-    // (like "AFT"), even if we add a well-known timezone abbreviation like
-    // "UTC" or "Z".
-    const date = new Date(dtStr)
-    if (isAtprotoDate(date)) {
-      return date.toISOString()
-    }
-  } else {
-    // If there is no timezone information, try parsing as UTC using two
-    // different syntaxes, falling back to parsing "as is".
-
-    const dateZ = new Date(`${dtStr}Z`)
-    if (isAtprotoDate(dateZ)) {
-      return dateZ.toISOString()
-    }
-
-    const dateUTC = new Date(`${dtStr} UTC`)
-    if (isAtprotoDate(dateUTC)) {
-      return dateUTC.toISOString()
-    }
-
-    // Despite our best efforts to parse as a consistent value, appending "Z" or
-    // " UTC" did not work, so we will try parsing "as is", which may yield
-    // different results depending on the local timezone of the machine.
-    const date = new Date(dtStr)
-    if (isAtprotoDate(date)) {
-      return date.toISOString()
-    }
-  }
-
-  throw new InvalidDatetimeError(
-    'datetime did not parse as any timestamp format',
-  )
-}
-
-/**
- * Variant of {@link normalizeDatetime} which always returns a valid datetime
- * string.
- *
- * If a {@link InvalidDatetimeError} is encountered, returns the UNIX epoch time
- * as a UTC datetime (`1970-01-01T00:00:00.000Z`).
- *
- * @see {@link normalizeDatetime}
- */
-export function normalizeDatetimeAlways(dtStr: string): ISODatetimeString {
-  try {
-    return normalizeDatetime(dtStr)
-  } catch (err) {
-    return '1970-01-01T00:00:00.000Z'
-  }
-}
-
-// Legacy exports (should we deprecate these ?)
-export {
-  assertDatetimeString as ensureValidDatetime,
-  isDatetimeString as isValidDatetime,
-}
-
-// -----------------------------------------------------------------------------
-// ------------------------- Internal validation logic -------------------------
-// -----------------------------------------------------------------------------
-
-// Validation utils that allow avoiding try/catch for control flow (performance
-// optimization). Other syntax formats should also use this pattern to avoid
-// try/catch in their validation logic, at which point these utils can be moved
-// to a common internal utils.
-type FailureResult = { success: false; message: string }
-const failure = (m: string): FailureResult => ({ success: false, message: m })
-type SuccessResult<V> = { success: true; value: V }
-const success = <V>(v: V): SuccessResult<V> => ({ success: true, value: v })
-type Result<V> = FailureResult | SuccessResult<V>
-
-/**
- * @see {@link https://www.rfc-editor.org/rfc/rfc3339#section-5.6 Internet Date/Time Format}
- *
- * @example
- * ```abnf
- * date-fullyear   = 4DIGIT
- * date-month      = 2DIGIT  ; 01-12
- * date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on
- *                           ; month/year
- * time-hour       = 2DIGIT  ; 00-23
- * time-minute     = 2DIGIT  ; 00-59
- * time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second
- *                           ; rules
- * time-secfrac    = "." 1*DIGIT
- * time-numoffset  = ("+" / "-") time-hour ":" time-minute
- * time-offset     = "Z" / time-numoffset
- * partial-time    = time-hour ":" time-minute ":" time-second
- *                   [time-secfrac]
- * full-date       = date-fullyear "-" date-month "-" date-mday
- * full-time       = partial-time time-offset
- * date-time       = full-date "T" full-time
- * ```
- */
-const DATETIME_REGEX =
-  /^(?<full_year>[0-9]{4})-(?<date_month>0[1-9]|1[012])-(?<date_mday>[0-2][0-9]|3[01])T(?<time_hour>[0-1][0-9]|2[0-3]):(?<time_minute>[0-5][0-9]):(?<time_second>[0-5][0-9]|60)(?<time_secfrac>\.[0-9]+)?(?<time_offset>Z|(?<time_numoffset>[+-](?:[0-1][0-9]|2[0-3]):[0-5][0-9]))$/
-
-/**
- * Validates that the input is a datetime string according to atproto Lexicon
- * rules, and parses it into a Date object.
- */
-function parseString(input: unknown): Result<AtprotoDate> {
-  // @NOTE Performing cheap tests first
-  if (typeof input !== 'string') {
-    return failure('datetime must be a string')
-  }
-  if (input.length > 64) {
-    return failure('datetime is too long (64 chars max)')
-  }
-  if (input.endsWith('-00:00')) {
-    return failure('datetime can not use "-00:00" for UTC timezone')
-  }
-  if (!DATETIME_REGEX.test(input)) {
-    return failure(
-      "datetime is not in a valid format (must match RFC 3339 & ISO 8601 with 'Z' or ±hh:mm timezone)",
-    )
-  }
-
-  // must parse as ISO 8601; this also verifies semantics like leap seconds and
-  // correct number of days in month, which the regex does not check for
-  const date = new Date(input)
-
-  return parseDate(date)
-}
-
-/**
- * Ensures that a Date object represents a valid datetime according to atproto
- * Lexicon rules. This ensures that `date.toISOString()` will produce a valid
- * datetime string that can be used where {@link DatetimeString} is expected.
- */
-function parseDate(date: Date): Result<AtprotoDate> {
-  const fullYear = date.getUTCFullYear()
-  // Ensures that the date is valid. We could check isNaN(date.getTime()) here
-  // but since we'll check the year anyway, we just use that for the validity
-  // check since an invalid date will have NaN year.
-  if (Number.isNaN(fullYear)) {
-    return failure('datetime did not parse as ISO 8601')
-  }
-  // Ensure that the ISO string representation does not start with ±YYYYYY
-  if (fullYear < 0) {
-    return failure('datetime normalized to a negative time')
-  }
-  if (fullYear > 9999) {
-    return failure('datetime year is too far in the future')
-  }
-  return success(date as AtprotoDate)
-}

package/src/did.ts

@@ -1,71 +0,0 @@
-// Human-readable constraints:
-//   - valid W3C DID (https://www.w3.org/TR/did-core/#did-syntax)
-//      - entire URI is ASCII: [a-zA-Z0-9._:%-]
-//      - always starts "did:" (lower-case)
-//      - method name is one or more lower-case letters, followed by ":"
-//      - remaining identifier can have any of the above chars, but can not end in ":"
-//      - it seems that a bunch of ":" can be included, and don't need spaces between
-//      - "%" is used only for "percent encoding" and must be followed by two hex characters (and thus can't end in "%")
-//      - query ("?") and fragment ("#") stuff is defined for "DID URIs", but not as part of identifier itself
-//      - "The current specification does not take a position on the maximum length of a DID"
-//   - in current atproto, only allowing did:plc and did:web. But not *forcing* this at lexicon layer
-//   - hard length limit of 8KBytes
-//   - not going to validate "percent encoding" here
-
-export type DidString<M extends string = string> = `did:${M}:${string}`
-
-export function ensureValidDid<I extends string>(
-  input: I,
-): asserts input is I & DidString {
-  if (!input.startsWith('did:')) {
-    throw new InvalidDidError('DID requires "did:" prefix')
-  }
-
-  if (input.length > 2048) {
-    throw new InvalidDidError('DID is too long (2048 chars max)')
-  }
-
-  if (input.endsWith(':') || input.endsWith('%')) {
-    throw new InvalidDidError('DID can not end with ":" or "%"')
-  }
-
-  // check that all chars are boring ASCII
-  if (!/^[a-zA-Z0-9._:%-]*$/.test(input)) {
-    throw new InvalidDidError(
-      'Disallowed characters in DID (ASCII letters, digits, and a couple other characters only)',
-    )
-  }
-
-  const { length, 1: method } = input.split(':')
-  if (length < 3) {
-    throw new InvalidDidError(
-      'DID requires prefix, method, and method-specific content',
-    )
-  }
-
-  if (!/^[a-z]+$/.test(method)) {
-    throw new InvalidDidError('DID method must be lower-case letters')
-  }
-}
-
-const DID_REGEX = /^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/
-
-export function ensureValidDidRegex<I extends string>(
-  input: I,
-): asserts input is I & DidString {
-  // simple regex to enforce most constraints via just regex and length.
-  // hand wrote this regex based on above constraints
-  if (!DID_REGEX.test(input)) {
-    throw new InvalidDidError("DID didn't validate via regex")
-  }
-
-  if (input.length > 2048) {
-    throw new InvalidDidError('DID is too long (2048 chars max)')
-  }
-}
-
-export function isValidDid<I extends string>(input: I): input is I & DidString {
-  return input.length <= 2048 && DID_REGEX.test(input)
-}
-
-export class InvalidDidError extends Error {}

package/src/handle.ts

@@ -1,128 +0,0 @@
-export const INVALID_HANDLE = 'handle.invalid'
-
-export type HandleString = `${string}.${string}`
-
-// Currently these are registration-time restrictions, not protocol-level
-// restrictions. We have a couple accounts in the wild that we need to clean up
-// before hard-disallow.
-// See also: https://en.wikipedia.org/wiki/Top-level_domain#Reserved_domains
-export const DISALLOWED_TLDS = [
-  '.local',
-  '.arpa',
-  '.invalid',
-  '.localhost',
-  '.internal',
-  '.example',
-  '.alt',
-  // policy could concievably change on ".onion" some day
-  '.onion',
-  // NOTE: .test is allowed in testing and devopment. In practical terms
-  // "should" "never" actually resolve and get registered in production
-]
-
-// Handle constraints, in English:
-//  - must be a possible domain name
-//    - RFC-1035 is commonly referenced, but has been updated. eg, RFC-3696,
-//      section 2. and RFC-3986, section 3. can now have leading numbers (eg,
-//      4chan.org)
-//    - "labels" (sub-names) are made of ASCII letters, digits, hyphens
-//    - can not start or end with a hyphen
-//    - TLD (last component) should not start with a digit
-//    - can't end with a hyphen (can end with digit)
-//    - each segment must be between 1 and 63 characters (not including any periods)
-//    - overall length can't be more than 253 characters
-//    - separated by (ASCII) periods; does not start or end with period
-//    - case insensitive
-//    - domains (handles) are equal if they are the same lower-case
-//    - punycode allowed for internationalization
-//  - no whitespace, null bytes, joining chars, etc
-//  - does not validate whether domain or TLD exists, or is a reserved or
-//    special TLD (eg, .onion or .local)
-//  - does not validate punycode
-export function ensureValidHandle<I extends string>(
-  input: I,
-): asserts input is I & HandleString {
-  // check that all chars are boring ASCII
-  if (!/^[a-zA-Z0-9.-]*$/.test(input)) {
-    throw new InvalidHandleError(
-      'Disallowed characters in handle (ASCII letters, digits, dashes, periods only)',
-    )
-  }
-
-  if (input.length > 253) {
-    throw new InvalidHandleError('Handle is too long (253 chars max)')
-  }
-  const labels = input.split('.')
-  if (labels.length < 2) {
-    throw new InvalidHandleError('Handle domain needs at least two parts')
-  }
-  for (let i = 0; i < labels.length; i++) {
-    const l = labels[i]
-    if (l.length < 1) {
-      throw new InvalidHandleError('Handle parts can not be empty')
-    }
-    if (l.length > 63) {
-      throw new InvalidHandleError('Handle part too long (max 63 chars)')
-    }
-    if (l.endsWith('-') || l.startsWith('-')) {
-      throw new InvalidHandleError(
-        'Handle parts can not start or end with hyphens',
-      )
-    }
-    if (i + 1 === labels.length && !/^[a-zA-Z]/.test(l)) {
-      throw new InvalidHandleError(
-        'Handle final component (TLD) must start with ASCII letter',
-      )
-    }
-  }
-}
-
-// simple regex translation of above constraints
-const HANDLE_REGEX =
-  /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/
-
-export function ensureValidHandleRegex<I extends string>(
-  input: I,
-): asserts input is I & HandleString {
-  if (input.length > 253) {
-    throw new InvalidHandleError('Handle is too long (253 chars max)')
-  }
-  if (!HANDLE_REGEX.test(input)) {
-    throw new InvalidHandleError("Handle didn't validate via regex")
-  }
-}
-
-export function normalizeHandle(handle: HandleString): HandleString
-export function normalizeHandle(handle: string): string
-export function normalizeHandle(handle: string): string {
-  return handle.toLowerCase()
-}
-
-export function normalizeAndEnsureValidHandle(handle: string): HandleString {
-  const normalized = normalizeHandle(handle)
-  ensureValidHandle(normalized)
-  return normalized
-}
-
-export function isValidHandle<I extends string>(
-  input: I,
-): input is I & HandleString {
-  return input.length <= 253 && HANDLE_REGEX.test(input)
-}
-
-export function isValidTld(handle: string): boolean {
-  for (const tld of DISALLOWED_TLDS) {
-    if (handle.endsWith(tld)) {
-      return false
-    }
-  }
-  return true
-}
-
-export class InvalidHandleError extends Error {}
-/** @deprecated Never used */
-export class ReservedHandleError extends Error {}
-/** @deprecated Never used */
-export class UnsupportedDomainError extends Error {}
-/** @deprecated Never used */
-export class DisallowedDomainError extends Error {}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './at-identifier.js'
-export * from './aturi.js'
-export * from './datetime.js'
-export * from './did.js'
-export * from './handle.js'
-export * from './nsid.js'
-export * from './language.js'
-export * from './recordkey.js'
-export * from './tid.js'
-export * from './uri.js'

package/src/language.ts

@@ -1,39 +0,0 @@
-const BCP47_REGEXP =
-  /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/
-
-export type LanguageTag = {
-  grandfathered?: string
-  language?: string
-  extlang?: string
-  script?: string
-  region?: string
-  variant?: string
-  extension?: string
-  privateUse?: string
-}
-
-export function parseLanguageString(input: string): LanguageTag | null {
-  const parsed = input.match(BCP47_REGEXP)
-  if (!parsed?.groups) return null
-
-  const { groups } = parsed
-  return {
-    grandfathered: groups.grandfathered,
-    language: groups.language,
-    extlang: groups.extlang,
-    script: groups.script,
-    region: groups.region,
-    variant: groups.variant,
-    extension: groups.extension,
-    privateUse: groups.privateUseA || groups.privateUseB,
-  }
-}
-
-/**
- * Validates well-formed BCP 47 syntax
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}
- */
-export function isValidLanguage(input: string): boolean {
-  return BCP47_REGEXP.test(input)
-}

package/src/lib/result.ts

@@ -1,11 +0,0 @@
-export type Result<T> = Success<T> | Failure
-
-export type Success<T> = { success: true; value: T }
-export function success<T>(value: T): Success<T> {
-  return { success: true, value }
-}
-
-export type Failure = { success: false; message: string }
-export function failure(message: string): Failure {
-  return { success: false, message }
-}