import: # imports must be resolved first
  pkg1: path/to/pkg # external package
  pkg2: "@/path/to/pkg" # package from same mod (proj/space)

io: # args (generics) may be omitted
  in:
    a: pkg1.externalType # reference to type from external package
    b: pkg2.externalType
    c: localType # reference to type in types.yaml in same folder

# di means this component must be initiated before use - it must get its deps
di: # di and import are sources of what workers may refer to
  dep1: pkg1.externalInterface
  dep2: pkg2.externalInterface
  dep3: localInterface # defined in types.yml in same folder (or *.t.yml files?)

workers: # components instances to do work in the network
  w1:
    ref: pkg1.externalComponent
  w2:
    ref: pkg1.externalComponentWithDI
    di:
      dep: pkg1.externalComponent # di in action

program:
  root: users
  pkgs:
    users:
      imports: [std/strings, humans]
      types: # `bool, int, float, str, sig, map, list, maybe` - reserved words (builtin types)
        user:
          id: int
          human: humans.human
          friends: list<user>
          bestFriend: maybe<user>
          mapExample: map<user> # only type references (not defs) (with generic args) allowed
      interfaces:
        stringer<T>: # if regexp.MatchString(s, `.+<(.\,*)+>`) {}
          in:
            in: T
          out:
            out: str
      components:
        root:
          di:
            stringer0: stringer
            stringer1: std/strings.stringer
          nodes:
            io<T>:
              in:
                run: sig # alias for empty struct (or use any?)
              out:
                bar: str
            static: # const
              foo:
                type: user
                value: #?
                  human:
                    age: 42
                    name: "john"
                  friends: []
                  bestFriend: null
            component: # workers
              stringer0: di.stringer0                       # di ref 1
              stringer1: di.stringer1                       # di ref 2
              stringer2: import.std/strings.defaultStringer # direct ref
          net:
            in.foo:
              - component.stringer0
              - component.stringer1
              - component.stringer2
            component.stringer0: out.bar
            component.stringer1: out.bar
            component.stringer2: out.bar
      root: root
    humans:
      types:
        human:
          age:
            ref: int
          name:
            ref: string
      exports:
        types:
          - human
    std/strings:
      interfaces:
        stringer:
          args: [T]
          in:
            in: T
          out:
            out: str
      components:
        defaultStringer: ...

imports:
  dep: path/to/package # every import has an alias

io:
  in:
    a: dep.ExternalType # reference to imported type
  out:
    b: dep.ExternalType

nodes:
  workers:
    w1: asIs # local imports not are not defined in `imports`
    w2: dep.asIs

net:
  in.a:
    - w1.a
  w1.b:
    - w2.a
  w2.b:
    - out.b

deps:
  import: # direct
    dep1: modref/path/to/package
  interface: # indirect
    dep2:
      ref: localInterface
    dep3:
      ref: dep1.externalInterface # like os.Writer