polen 0.11.0-next.13 → 0.11.0-next.15

package/src/lib/lifecycles/lifecycles.ts

@@ -0,0 +1,521 @@
+import { Catalog } from '#lib/catalog/$'
+import { Change } from '#lib/change/$'
+import { Revision } from '#lib/revision/$'
+import { Schema } from '#lib/schema/$'
+import { Version } from '#lib/version/$'
+import { Match } from 'effect'
+
+// ============================================================================
+// Lifecycles Type - Simple Index
+// ============================================================================
+
+/**
+ * A change entry tracking when a type or field was modified
+ */
+export interface ChangeEntry {
+  /** The change that occurred */
+  change: Change.Change
+  /** The revision containing this change */
+  revision: Revision.Revision
+  /** The schema this change belongs to */
+  schema: Schema.Schema
+}
+
+/**
+ * Lifecycles is a simple index mapping type names to their change history
+ */
+export type Lifecycles = Record<string, ChangeEntry[]>
+
+// ============================================================================
+// Since Types - For tracking when things were introduced
+// ============================================================================
+
+/**
+ * Represents when a type or field was introduced
+ */
+export type Since =
+  | { _tag: 'initial' }
+  | { _tag: 'added'; revision: Revision.Revision; change: Change.Change; schema: Schema.Schema }
+
+// ============================================================================
+// Domain Logic - Create Function
+// ============================================================================
+
+/**
+ * Extract the type name from a change
+ */
+const extractTypeNameFromChange = (change: Change.Change): string | null => {
+  return Match.value(change).pipe(
+    Match.tag('TYPE_ADDED', (c) => c.name),
+    Match.tag('TYPE_REMOVED', (c) => c.name),
+    Match.tag('FIELD_ADDED', (c) => c.typeName),
+    Match.tag('FIELD_REMOVED', (c) => c.typeName),
+    Match.tag('INPUT_FIELD_ADDED', (c) => c.inputName),
+    Match.tag('INPUT_FIELD_REMOVED', (c) => c.inputName),
+    Match.tag('ENUM_VALUE_ADDED', (c) => c.enumName),
+    Match.tag('ENUM_VALUE_REMOVED', (c) => c.enumName),
+    Match.tag('UNION_MEMBER_ADDED', (c) => c.unionName),
+    Match.tag('UNION_MEMBER_REMOVED', (c) => c.unionName),
+    Match.tag('OBJECT_TYPE_INTERFACE_ADDED', (c) => c.objectName),
+    Match.tag('OBJECT_TYPE_INTERFACE_REMOVED', (c) => c.objectName),
+    Match.orElse(() => null),
+  )
+}
+
+/**
+ * Build lifecycle data from a single schema
+ */
+export const createFromSchema = (schema: Schema.Schema): Lifecycles => {
+  const lifecycles: Lifecycles = {}
+
+  // Process all revisions for this schema
+  for (const revision of schema.revisions) {
+    // Process all changes in this revision
+    for (const change of revision.changes) {
+      const typeName = extractTypeNameFromChange(change)
+      if (typeName) {
+        if (!lifecycles[typeName]) {
+          lifecycles[typeName] = []
+        }
+        lifecycles[typeName].push({
+          change, // reference to existing change object
+          revision, // reference to existing revision object
+          schema, // reference to existing schema object
+        })
+      }
+    }
+  }
+
+  return lifecycles
+}
+
+/**
+ * Build lifecycle data from a catalog
+ */
+export const create = (catalog: Catalog.Catalog): Lifecycles => {
+  const lifecycles: Lifecycles = {}
+
+  const processSchema = (schema: Schema.Schema) => {
+    // Process all revisions for this schema
+    for (const revision of schema.revisions) {
+      // Process all changes in this revision
+      for (const change of revision.changes) {
+        const typeName = extractTypeNameFromChange(change)
+        if (typeName) {
+          if (!lifecycles[typeName]) {
+            lifecycles[typeName] = []
+          }
+          lifecycles[typeName].push({
+            change, // reference to existing change object
+            revision, // reference to existing revision object
+            schema, // reference to existing schema object
+          })
+        }
+      }
+    }
+  }
+
+  // Process based on catalog type
+  Catalog.fold(
+    // Versioned catalog - process each versioned schema
+    (versioned) => {
+      for (const schema of versioned.entries) {
+        processSchema(schema)
+      }
+    },
+    // Unversioned catalog - process the single schema
+    (unversioned) => {
+      processSchema(unversioned.schema)
+    },
+  )(catalog)
+
+  return lifecycles
+}
+
+// ============================================================================
+// Domain Logic - Utility Functions for Types
+// ============================================================================
+
+/**
+ * Get when a type was introduced (initial or added)
+ */
+export const getTypeSince = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  currentSchema?: Schema.Schema,
+): Since | undefined => {
+  const entries = lifecycles[typeName]
+
+  // If no entries at all, type doesn't exist in any form
+  if (!entries || entries.length === 0) return undefined
+
+  // Look for TYPE_ADDED change
+  for (const entry of entries) {
+    if (entry.change._tag === 'TYPE_ADDED' && entry.change.name === typeName) {
+      // If we have a current version and this entry has a version, check if it's not after current
+      if (currentSchema && entry.schema._tag === 'SchemaVersioned') {
+        if (currentSchema._tag !== 'SchemaVersioned') throw new Error('todo -- version/unversioned mismatch!')
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentSchema.version)) {
+          continue // Skip entries from future versions
+        }
+      }
+
+      // Found when it was added
+      return {
+        _tag: 'added',
+        revision: entry.revision,
+        change: entry.change,
+        schema: entry.schema,
+      }
+    }
+  }
+
+  // No TYPE_ADDED found, so it must have existed from initial schema
+  return { _tag: 'initial' }
+}
+
+/**
+ * Get the date when a type was added
+ * Shows when the type was first introduced via TYPE_ADDED change
+ * Returns undefined if type existed from initial schema (no TYPE_ADDED change)
+ */
+export const getTypeAddedDate = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  currentVersion?: string,
+): Date | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // Parse current version if provided
+  const currentVer = currentVersion ? Version.fromString(currentVersion) : undefined
+
+  // Find the earliest TYPE_ADDED change that's not after the current version
+  let earliestDate: Date | undefined
+
+  for (const entry of entries) {
+    if (entry.change._tag === 'TYPE_ADDED' && entry.change.name === typeName) {
+      // If we have a current version and this entry has a version, check if it's not after current
+      if (currentVer && entry.schema._tag === 'SchemaVersioned') {
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentVer)) {
+          continue // Skip entries from future versions
+        }
+      }
+
+      const date = new Date(entry.revision.date)
+      if (!earliestDate || date < earliestDate) {
+        earliestDate = date
+      }
+    }
+  }
+
+  return earliestDate
+}
+
+/**
+ * Get the date when a type was removed
+ * For reference docs: Returns undefined if type exists in current version (no removal badge should be shown)
+ * For changelog: Shows removal date if it happened in any version
+ */
+export const getTypeRemovedDate = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  currentSchema?: Schema.Schema,
+): Date | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // If no current schema specified (e.g., in changelog), show any removal
+  if (!currentSchema) {
+    // Find the latest TYPE_REMOVED change
+    let latestDate: Date | undefined
+
+    for (const entry of entries) {
+      if (entry.change._tag === 'TYPE_REMOVED' && entry.change.name === typeName) {
+        const date = new Date(entry.revision.date)
+        if (!latestDate || date > latestDate) {
+          latestDate = date
+        }
+      }
+    }
+
+    return latestDate
+  }
+
+  // For reference docs with current schema:
+  // Only show removal if it happens AFTER the current version (future removal warning)
+  // If the type exists in the current version, it cannot have been removed
+  const currentVer = Schema.getVersion(currentSchema)
+  if (!currentVer) return undefined
+
+  for (const entry of entries) {
+    if (entry.change._tag === 'TYPE_REMOVED' && entry.change.name === typeName) {
+      // Check if removal is after current version
+      if (entry.schema._tag === 'SchemaVersioned') {
+        if (currentSchema._tag !== 'SchemaVersioned') throw new Error('todo -- version/unversioned mismatch!')
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentVer)) {
+          // This is a future removal - could show as a deprecation warning
+          // But for now, we don't show future removals
+          return undefined
+        }
+      }
+    }
+  }
+
+  // No removal found or removal is in the past (but type still exists in current version)
+  return undefined
+}
+
+/**
+ * Check if a type is currently available (not removed)
+ */
+export const isTypeCurrentlyAvailable = (lifecycles: Lifecycles, typeName: string): boolean => {
+  const entries = lifecycles[typeName]
+  if (!entries || entries.length === 0) return false
+
+  // Check if type was ever added
+  const wasAdded = entries.some(e => e.change._tag === 'TYPE_ADDED' && e.change.name === typeName)
+  if (!wasAdded) return false
+
+  // Check if it was subsequently removed
+  const addedDate = getTypeAddedDate(lifecycles, typeName)
+  const removedDate = getTypeRemovedDate(lifecycles, typeName)
+
+  if (!addedDate) return false
+  if (!removedDate) return true
+
+  // If both dates exist, type is available if it was re-added after being removed
+  // This would require multiple add/remove cycles - for now assume removed means not available
+  return false
+}
+
+// ============================================================================
+// Domain Logic - Utility Functions for Fields
+// ============================================================================
+
+/**
+ * Get when a field was introduced (initial or added)
+ */
+export const getFieldSince = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+  currentSchema?: Schema.Schema,
+): Since | undefined => {
+  const entries = lifecycles[typeName]
+
+  // If no entries for the type, we can't determine field info
+  if (!entries || entries.length === 0) return undefined
+
+  // Get current version from schema if provided
+  const currentVer = currentSchema ? Schema.getVersion(currentSchema) : undefined
+
+  // Look for FIELD_ADDED or INPUT_FIELD_ADDED change
+  for (const entry of entries) {
+    const isFieldAdded = (entry.change._tag === 'FIELD_ADDED'
+      && entry.change.typeName === typeName
+      && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'INPUT_FIELD_ADDED'
+        && entry.change.inputName === typeName
+        && entry.change.fieldName === fieldName)
+
+    if (isFieldAdded) {
+      // If we have a current version and this entry has a version, check if it's not after current
+      if (currentVer && entry.schema._tag === 'SchemaVersioned') {
+        if (currentSchema && currentSchema._tag !== 'SchemaVersioned') {
+          throw new Error('todo -- version/unversioned mismatch!')
+        }
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentVer)) {
+          continue // Skip entries from future versions
+        }
+      }
+
+      // Found when it was added
+      return {
+        _tag: 'added',
+        revision: entry.revision,
+        change: entry.change,
+        schema: entry.schema,
+      }
+    }
+  }
+
+  // No FIELD_ADDED found, so it must have existed from initial schema
+  // But only if the type itself exists (has some entries)
+  return { _tag: 'initial' }
+}
+
+/**
+ * Get the date when a field was added
+ * Shows when the field was first introduced via FIELD_ADDED change
+ * Returns undefined if field existed from initial schema (no FIELD_ADDED change)
+ */
+export const getFieldAddedDate = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+  currentSchema?: Schema.Schema,
+): Date | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // Get current version from schema if provided
+  const currentVer = currentSchema ? Schema.getVersion(currentSchema) : undefined
+
+  // Find the earliest FIELD_ADDED or INPUT_FIELD_ADDED change for this field
+  let earliestDate: Date | undefined
+
+  for (const entry of entries) {
+    const isFieldAdded = (entry.change._tag === 'FIELD_ADDED'
+      && entry.change.typeName === typeName
+      && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'INPUT_FIELD_ADDED'
+        && entry.change.inputName === typeName
+        && entry.change.fieldName === fieldName)
+
+    if (isFieldAdded) {
+      // If we have a current version and this entry has a version, check if it's not after current
+      if (currentVer && entry.schema._tag === 'SchemaVersioned') {
+        if (currentSchema && currentSchema._tag !== 'SchemaVersioned') {
+          throw new Error('todo -- version/unversioned mismatch!')
+        }
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentVer)) {
+          continue // Skip entries from future versions
+        }
+      }
+
+      const date = new Date(entry.revision.date)
+      if (!earliestDate || date < earliestDate) {
+        earliestDate = date
+      }
+    }
+  }
+
+  return earliestDate
+}
+
+/**
+ * Get the date when a field was removed
+ * For reference docs: Returns undefined if field exists in current version (no removal badge should be shown)
+ * For changelog: Shows removal date if it happened in any version
+ */
+export const getFieldRemovedDate = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+  currentSchema?: Schema.Schema,
+): Date | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // If no current schema specified (e.g., in changelog), show any removal
+  if (!currentSchema) {
+    // Find the latest FIELD_REMOVED or INPUT_FIELD_REMOVED change for this field
+    let latestDate: Date | undefined
+
+    for (const entry of entries) {
+      const isFieldRemoved = (entry.change._tag === 'FIELD_REMOVED'
+        && entry.change.typeName === typeName
+        && entry.change.fieldName === fieldName)
+        || (entry.change._tag === 'INPUT_FIELD_REMOVED'
+          && entry.change.inputName === typeName
+          && entry.change.fieldName === fieldName)
+
+      if (isFieldRemoved) {
+        const date = new Date(entry.revision.date)
+        if (!latestDate || date > latestDate) {
+          latestDate = date
+        }
+      }
+    }
+
+    return latestDate
+  }
+
+  // For reference docs with current version:
+  // If the field exists in the current version's schema, it cannot have been removed
+  // So we return undefined (no removal badge should be shown)
+  return undefined
+}
+
+/**
+ * Check if a field is currently available (not removed)
+ */
+export const isFieldCurrentlyAvailable = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+): boolean => {
+  const entries = lifecycles[typeName]
+  if (!entries || entries.length === 0) return false
+
+  // Check if field was ever added
+  const addedDate = getFieldAddedDate(lifecycles, typeName, fieldName)
+  if (!addedDate) return false
+
+  // Check if it was subsequently removed
+  const removedDate = getFieldRemovedDate(lifecycles, typeName, fieldName)
+  if (!removedDate) return true
+
+  // If both dates exist, field is not available if it was removed
+  return false
+}
+
+// ============================================================================
+// Domain Logic - Compatibility Functions (for existing code)
+// ============================================================================
+
+/**
+ * Get field lifecycle info (for compatibility with existing UI code)
+ */
+export const getFieldLifecycle = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+): { events: ChangeEntry[] } | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // Filter entries related to this specific field
+  const fieldEntries = entries.filter(entry => {
+    return (entry.change._tag === 'FIELD_ADDED'
+      && entry.change.typeName === typeName
+      && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'FIELD_REMOVED'
+        && entry.change.typeName === typeName
+        && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'INPUT_FIELD_ADDED'
+        && entry.change.inputName === typeName
+        && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'INPUT_FIELD_REMOVED'
+        && entry.change.inputName === typeName
+        && entry.change.fieldName === fieldName)
+  })
+
+  if (fieldEntries.length === 0) return undefined
+
+  // Return in a format compatible with existing code that expects an object with events
+  return { events: fieldEntries }
+}
+
+/**
+ * Get type lifecycle info (for compatibility with existing UI code)
+ */
+export const getTypeLifecycle = (lifecycles: Lifecycles, typeName: string): { events: ChangeEntry[] } | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // Filter entries related to type-level changes
+  const typeEntries = entries.filter(entry => {
+    return entry.change._tag === 'TYPE_ADDED' || entry.change._tag === 'TYPE_REMOVED'
+  })
+
+  if (typeEntries.length === 0) return undefined
+
+  return { events: typeEntries }
+}

package/src/lib/mask/$.test.ts

@@ -1,93 +1,71 @@
 import * as fc from 'fast-check'
 import { describe, expect, test } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
 import { Mask } from './$.js'
 
-describe('Mask.create', () => {
-  test('boolean options create binary masks', () => {
-    const showMask = Mask.create(true)
-    const hideMask = Mask.create(false)
-
-    expect(showMask.type).toBe('binary')
-    expect(hideMask.type).toBe('binary')
-
-    if (showMask.type === 'binary' && hideMask.type === 'binary') {
-      expect(showMask.show).toBe(true)
-      expect(hideMask.show).toBe(false)
-    }
-  })
-
-  test('array options create allow mode properties mask', () => {
-    const mask = Mask.create(['name', 'age'])
-
-    expect(mask.type).toBe('properties')
-    if (mask.type === 'properties') {
-      expect(mask.mode).toBe('allow')
-      expect(mask.properties).toEqual(['name', 'age'])
-    }
-  })
-
-  test('object options create mode based on values', () => {
-    const allowMask = Mask.create({ name: true, age: true, password: false })
-    const denyMask = Mask.create({ password: false, secret: false })
-
-    expect(allowMask.type).toBe('properties')
-    expect(denyMask.type).toBe('properties')
-
-    if (allowMask.type === 'properties' && denyMask.type === 'properties') {
-      expect(allowMask.mode).toBe('allow')
-      expect(allowMask.properties).toEqual(['name', 'age'])
-
-      expect(denyMask.mode).toBe('deny')
-      expect(denyMask.properties).toEqual(['password', 'secret'])
-    }
-  })
+// dprint-ignore
+Test.suite<{ options: any; expectedType: 'binary' | 'properties'; expectedMode?: 'allow' | 'deny'; expectedShow?: boolean; expectedProperties?: string[] }>('Mask.create', [
+  { name: 'boolean true creates binary show mask',       options: true,                                        expectedType: 'binary',     expectedShow: true },
+  { name: 'boolean false creates binary hide mask',      options: false,                                       expectedType: 'binary',     expectedShow: false },
+  { name: 'array creates allow mode properties mask',    options: ['name', 'age'],                             expectedType: 'properties', expectedMode: 'allow', expectedProperties: ['name', 'age'] },
+  { name: 'object with true values creates allow mode',  options: { name: true, age: true, password: false },  expectedType: 'properties', expectedMode: 'allow', expectedProperties: ['name', 'age'] },
+  { name: 'object with false values creates deny mode',  options: { password: false, secret: false },          expectedType: 'properties', expectedMode: 'deny',  expectedProperties: ['password', 'secret'] },
+], ({ options, expectedType, expectedMode, expectedShow, expectedProperties }) => {
+  const mask = Mask.create(options)
+  expect(mask.type).toBe(expectedType)
+  
+  if (expectedType === 'binary' && mask.type === 'binary') {
+    expect(mask.show).toBe(expectedShow)
+  }
+  
+  if (expectedType === 'properties' && mask.type === 'properties') {
+    expect(mask.mode).toBe(expectedMode)
+    expect(mask.properties).toEqual(expectedProperties)
+  }
 })
 
-describe('Mask.apply', () => {
-  test('binary masks show/hide data', () => {
-    const data = { a: 1 }
-
-    expect(Mask.apply(data, Mask.create(true))).toBe(data)
-    expect(Mask.apply(data, Mask.create(false))).toBe(undefined)
-  })
-
-  test('properties masks filter objects', () => {
-    const data = { name: 'John', age: 30, password: 'secret' }
-
-    // Allow mode
-    const allowMask = Mask.create(['name', 'age'])
-    expect(Mask.apply(data, allowMask)).toEqual({ name: 'John', age: 30 })
-
-    // Deny mode
-    const denyMask = Mask.create({ password: false })
-    expect(Mask.apply(data, denyMask)).toEqual({ name: 'John', age: 30 })
-  })
-
-  test('properties masks throw for non-objects', () => {
-    const mask = Mask.create(['name'])
-
-    expect(() => Mask.apply('string' as any, mask)).toThrow()
-    expect(() => Mask.apply(123 as any, mask)).toThrow()
-    expect(() => Mask.apply(null as any, mask)).toThrow()
-  })
+// dprint-ignore
+Test.suite<{ data: any; maskOptions: any; shouldThrow?: boolean; expected?: any }>('Mask.apply', [
+  { name: 'binary show mask returns data',               data: { a: 1 },                                 maskOptions: true,              expected: { a: 1 } },
+  { name: 'binary hide mask returns undefined',          data: { a: 1 },                                 maskOptions: false,             expected: undefined },
+  { name: 'allow mode filters properties',               data: { name: 'John', age: 30, password: 'secret' }, maskOptions: ['name', 'age'],    expected: { name: 'John', age: 30 } },
+  { name: 'deny mode removes properties',                data: { name: 'John', age: 30, password: 'secret' }, maskOptions: { password: false }, expected: { name: 'John', age: 30 } },
+  { name: 'properties mask throws for string',           data: 'string',                                 maskOptions: ['name'],          shouldThrow: true },
+  { name: 'properties mask throws for number',           data: 123,                                      maskOptions: ['name'],          shouldThrow: true },
+  { name: 'properties mask throws for null',             data: null,                                     maskOptions: ['name'],          shouldThrow: true },
+], ({ data, maskOptions, shouldThrow, expected }) => {
+  const mask = Mask.create(maskOptions)
+  
+  if (shouldThrow) {
+    expect(() => Mask.apply(data as any, mask)).toThrow()
+  } else {
+    const result = Mask.apply(data, mask)
+    if (expected === undefined) {
+      expect(result).toBe(undefined)
+    } else {
+      expect(result).toEqual(expected)
+    }
+  }
 })
 
-describe('apply variants', () => {
-  test('applyPartial allows missing properties', () => {
-    const mask = Mask.create<{ name: string; age: number }>(['name', 'age'])
-    const partial = { name: 'John' }
-
-    expect(Mask.applyPartial(partial, mask)).toEqual({ name: 'John' })
-    expect(Mask.applyPartial({}, mask)).toEqual({})
-  })
-
-  test('applyExact works with any data for binary masks', () => {
-    const showMask = Mask.create(true)
-    const hideMask = Mask.create(false)
-
-    expect(Mask.applyExact('hello' as any, showMask)).toBe('hello')
-    expect(Mask.applyExact('hello' as any, hideMask)).toBe(undefined)
-  })
+// dprint-ignore
+Test.suite<{ method: 'applyPartial' | 'applyExact'; data: any; maskOptions: any; expected: any }>('apply variants', [
+  { name: 'applyPartial allows missing properties',      method: 'applyPartial', data: { name: 'John' },  maskOptions: ['name', 'age'], expected: { name: 'John' } },
+  { name: 'applyPartial with empty object',              method: 'applyPartial', data: {},                maskOptions: ['name', 'age'], expected: {} },
+  { name: 'applyExact with binary show mask',            method: 'applyExact',   data: 'hello',           maskOptions: true,             expected: 'hello' },
+  { name: 'applyExact with binary hide mask',            method: 'applyExact',   data: 'hello',           maskOptions: false,            expected: undefined },
+], ({ method, data, maskOptions, expected }) => {
+  const mask = Mask.create(maskOptions)
+  
+  const result = method === 'applyPartial' 
+    ? Mask.applyPartial(data, mask)
+    : Mask.applyExact(data as any, mask)
+    
+  if (expected === undefined) {
+    expect(result).toBe(undefined)
+  } else {
+    expect(result).toEqual(expected)
+  }
 })
 
 describe('property-based tests', () => {